def prior(self, params):
mp = np.array([0.] * self.l)
qp = mp.copy()
if self.fixp:
pp = np.array([0.])
else:
pp = mp.copy()
sd = np.array([0.])
for i in range(self.l):
mp[i] = norm.logpdf(params['m'][i], self.pr['mp'][i][0],
self.pr['mp'][i][1])
#qp[i] = norm.logpdf(params['q'][i], self.pr['qp'][i][0],self.pr['qp'][i][1])
qp[i] = uniform.logpdf(params['q'][i], 0, 10)
if self.fixp is False:
pp[i] = uniform.logpdf(params['p'][i], 0, 10)
#pp[0] = norm.logpdf(params['p'][0], self.pr['pp'][0], self.pr['pp'][1])
if self.fixp:
pp[0] = uniform.logpdf(params["p"][0], 0, 5)
sd[0] = norm.logpdf(params['sd'][0], self.pr['sd'][0],
self.pr['sd'][1])
sumll = np.sum(mp) + np.sum(qp) + np.sum(pp) + sd
## Prior For price
if self.price is not None:
if self.hete:
ap = norm.logpdf(params["a"][0], self.pr["a"][0],
self.pr["a"][1])
else:
ap = 0
for i in params["a"]:
ap += norm.logpdf(params["a"][i], self.pr["a"][0],
self.pr["a"][1])
sumll += ap
return sumll[0]
def logprior(sig_r=None, sig_s=None, sig_i=None, rho1=None, rho2=None, rho3=None,
rbar=None, sbar=None, ibar=None,
sigma80=None, Om0=None, Om_a=0.01, Om_b=0.99, sig_star=None, **kwargs):
ret = 0.0
# Uniform priors (location parameters)
if rho1 is not None:
ret += uniform.logpdf(rho1, loc=-0.999, scale=1.998)
if rho2 is not None:
ret += uniform.logpdf(rho2, loc=-0.999, scale=1.998)
if rho3 is not None:
ret += uniform.logpdf(rho3, loc=-0.999, scale=1.998)
if rbar is not None:
ret += uniform.logpdf(rbar, loc=0.05, scale=0.25)
if sbar is not None:
ret += 0.0 # uniform.logpdf(sbar, loc=0.5, scale=5.0)
if ibar is not None:
ret += 0.0 # uniform.logpdf(ibar, loc=1.0, scale=6.0)
if Om0 is not None:
ret += uniform.logpdf(Om0, loc=Om_a, scale=Om_b-Om_a)
# Log Uniform priors (scale parameters)
if sig_r is not None:
ret += reciprocal.logpdf(sig_r, 1e-05, 1e+01)
if sig_s is not None:
ret += reciprocal.logpdf(sig_s, 1e-05, 1e+01)
if sig_i is not None:
ret += reciprocal.logpdf(sig_i, 1e-05, 1e+01)
if sigma80 is not None:
ret += reciprocal.logpdf(sigma80, 1e-05, 1e+01)
if sig_star is not None:
ret += reciprocal.logpdf(sig_star, 1e-02, 600.)
return ret
def compute_log_prior(self, params: ndarray) -> float:
"""Calcuales the the natural log of the prior p(params).
This implements the the fixed emperically determined priors from the
paper.
Args:
params : array of model parameters [ln_tE,ln_A0,ln_deltaT,fbl,mb],
or [ln(Einstien time),ln(Max Amplication),ln(time since alert),
blending paramerter,baseline magnitude],
shape = (5,).
Returns:
ln_prior : natural logarithm of the prior.
"""
ln_tE = params[0]
ln_A0 = params[1]
ln_deltaT = params[2]
fbl = params[3]
mb = params[4]
# Equation (16,15,17) (note that Albrow uses "log" for log10)
log10e = np.log10(np.exp(1))
ln_pr_ln_tE = np.log(0.476) - (
(log10e * ln_tE - 1.333)**2 / 0.330) + np.log(log10e)
ln_pr_ln_A0 = np.log(0.660) - (1.289 * log10e * ln_A0) + np.log(log10e)
ln_pr_ln_deltaT = np.log(0.156) - ((log10e*ln_deltaT - 1.432)**2 / 0.458) +\
np.log(log10e)
# Paper doesnt mention the prior used, but I assume it to be uniform
ln_pr_fbl = uniform.logpdf(fbl, 0.0, 1.0)
# Paper doesnr mention the prior used but I will asuumed it to be uniform
ln_pr_mb = uniform.logpdf(mb, self.mag_min - 1.0, self.mag_max + 1.0)
return ln_pr_fbl + ln_pr_ln_A0 + ln_pr_ln_deltaT + ln_pr_ln_tE + ln_pr_mb
def noise_density(params, x):
xy = x[['x', 'y']].values
dens_x = uniform.logpdf(xy[:, 0],
loc=xy[:, 0].min(),
scale=xy[:, 0].max() - xy[:, 0].min())
dens_y = uniform.logpdf(xy[:, 1],
loc=xy[:, 1].min(),
scale=xy[:, 1].max() - xy[:, 1].min())
return np.log(params['w']) + dens_x + dens_y
def prior(a, b, sd):
# 'uninformative' paramters for a_prior and b_prior
# (uniform distribution and normal distribution)
a_prior = uniform.logpdf(a, loc=0, scale=10) # MIN=loc, MAX=loc+scale
b_prior = norm.logpdf(b, scale=5) # loc=mean(default:0),scale=var
# 1/sigma is applied for denying standard deviation's informativeness.
# (check 'Jeffreys Prior' for more detail.)
# (add epsilon constant to avoid division by zero.)
sd_prior = 1 / (sd + eps) * uniform.logpdf(
sd, loc=0, scale=30) # MIN=loc, MAX=loc+scale
return a_prior + b_prior + sd_prior
def test_gaussian(self):
samples = []
for i in range(5000):
s = rejection_sample(
lambda x: norm.logpdf(x, 0, 1) - norm.logpdf(0, 0, 1),
lambda x: uniform.logpdf(x, -10, 20) - uniform.logpdf(
0, -10, 20),
lambda: uniform.rvs(-10, 20),
using_logs=True).send(None)
samples.append(s)
self.assertAlmostEqual(np.mean(samples), 0, places=3)
self.assertAlmostEqual(np.std(samples), 1, places=3)
def test_log_pdf(self, dtype, low, low_is_samples, high, high_is_samples, rv, rv_is_samples,
num_samples):
is_samples_any = any([low_is_samples, high_is_samples, rv_is_samples])
rv_shape = rv.shape[1:] if rv_is_samples else rv.shape
n_dim = 1 + len(rv.shape) if is_samples_any and not rv_is_samples else len(rv.shape)
low_np = numpy_array_reshape(low, low_is_samples, n_dim)
high_np = numpy_array_reshape(high, high_is_samples, n_dim)
scale_np = high_np - low_np
rv_np = numpy_array_reshape(rv, rv_is_samples, n_dim)
# Note uniform.logpdf takes loc and scale, where loc=a and scale=b-a
log_pdf_np = uniform.logpdf(rv_np, low_np, scale_np)
var = Uniform.define_variable(shape=rv_shape, dtype=dtype).factor
low_mx = mx.nd.array(low, dtype=dtype)
if not low_is_samples:
low_mx = add_sample_dimension(mx.nd, low_mx)
high_mx = mx.nd.array(high, dtype=dtype)
if not high_is_samples:
high_mx = add_sample_dimension(mx.nd, high_mx)
rv_mx = mx.nd.array(rv, dtype=dtype)
if not rv_is_samples:
rv_mx = add_sample_dimension(mx.nd, rv_mx)
variables = {var.low.uuid: low_mx, var.high.uuid: high_mx, var.random_variable.uuid: rv_mx}
log_pdf_rt = var.log_pdf(F=mx.nd, variables=variables)
assert np.issubdtype(log_pdf_rt.dtype, dtype)
assert array_has_samples(mx.nd, log_pdf_rt) == is_samples_any
if is_samples_any:
assert get_num_samples(mx.nd, log_pdf_rt) == num_samples
if np.issubdtype(dtype, np.float64):
rtol, atol = 1e-7, 1e-10
else:
rtol, atol = 1e-4, 1e-5
assert np.allclose(log_pdf_np, log_pdf_rt.asnumpy(), rtol=rtol, atol=atol)
def probability(self, x, log):
if self.log:
x = np.log(x)
if log:
out = np.squeeze(uniform.logpdf(x, self._min, self.scale))
return np.sum(out) if self.multivariate else out
else:
out = np.squeeze(uniform.pdf(x, self._min, self.scale))
return np.prod(out) if self.multivariate else out
def test_parameter_bounds(self):
x = Parameter(4, bounds=Interval(-4, 4))
assert_equal(x.logp(), uniform.logpdf(0, -4, 8))
x.bounds = None
assert_(isinstance(x._bounds, Interval))
assert_equal(x.bounds.lb, -np.inf)
assert_equal(x.bounds.ub, np.inf)
assert_equal(x.logp(), 0)
x.setp(bounds=norm(0, 1))
assert_almost_equal(x.logp(1), norm.logpdf(1, 0, 1))
# all created parameters were mistakenly being given the same
# default bounds instance!
x = Parameter(4)
y = Parameter(5)
assert_(id(x.bounds) != id(y.bounds))
def negPost(x, *args):
nWater = args[0]
nTosses = args[1]
p = -1 * (binom.logpmf(k=nWater, n=nTosses, p=x) + uniform.logpdf(x, 0, 1))
return p
#print(theta_draw)
params_m = [theta_draw[0], theta_draw[1], sigma_R]
params_t = [theta_draw[2], theta_draw[3], delta_2, sigma_Q]
z_t = z(params_m, params_t, x_t, y_t, M, c_init, r_star)
# Prior for gamma_0, gamma_1, delta_0 and delta_1
prior = multivariate_normal.logpdf(theta_draw[:4],
mean=np.array([2.74, -1.19, 0.5, 0.8]),
cov=2 * np.eye(4))
prior -= multivariate_normal.logpdf(theta[i][:4],
mean=np.array([2.74, -1.19, 0.5, 0.8]),
cov=2 * np.eye(4))
# Prior for delta_1
prior += uniform.logpdf(delta_2, -1, 2)
prior -= uniform.logpdf(np.tanh(theta[i][4]), -1, 2)
# Prior Sigma_R
prior += gamma.logpdf(sigma_R, a=5, scale=1 / 5)
prior -= gamma.logpdf(np.exp(theta[i][5]), a=5, scale=1 / 5)
# Prior Sigma_Q
prior += gamma.logpdf(sigma_Q, a=5, scale=1 / 5)
prior -= gamma.logpdf(np.exp(theta[i][6]), a=5, scale=1 / 5)
# Correct for Jacobian
logJacob = np.log(np.abs(1 - delta_2**2)) - np.log(
np.abs(1 - np.tanh(theta[i][4])**2))
logJacob += np.log(np.abs(sigma_R)) - np.log(np.abs(np.exp(theta[i][5])))
logJacob += np.log(np.abs(sigma_Q)) - np.log(np.abs(np.exp(theta[i][6])))
def evaluate_log_prior(self, parameters):
parameters = parameters.reshape((-1, self.parameter_dim()))
return np.sum(uniform.logpdf(parameters, loc=-1.0, scale=2.0), axis=1)
def uniform_adj_log_pdf(x, m, M):
return np.sum(uniform.logpdf(x, m, M))
def calc_log_prior(mu, sigma, alpha, beta, l, h):
log_sigma = gamma.logpdf(sigma, alpha, scale=beta)
log_mu = uniform.logpdf(mu, loc=l, scale=l + h)
return log_mu + log_sigma
def __call__(self, u: np.ndarray, y: float) -> np.ndarray:
loc = y - self.scale / 2
return uniform.logpdf(x=u, loc=loc, scale=self.scale)
d = pd.read_csv('rethinking-Experimental/data/Howell1.csv',
delimiter=';')
d2 = d.loc[d.age >= 18]
mu = np.linspace(140, 160, num=200)
sigma = np.linspace(4, 9, num=200)
post = pd.DataFrame([[x, y] for y in sigma for x in mu],
columns=['mu', 'sigma']
)
post['LL'] = np.sum(norm.logpdf(d2.height.values.reshape(1, -1),
loc=post.mu.values.reshape(-1, 1),
scale=post.sigma.values.reshape(-1, 1)),
axis=1)
post['logprod'] = post.LL + norm.logpdf(post.mu, 178, 20) +\
uniform.logpdf(post.sigma, 0, 50)
post['prob'] = np.exp(post.logprod - post.logprod.max())
post.head()
ax=post.plot.hexbin(x='mu', y='sigma', C='prob', cmap=cm.thermal)
ax.set_xlabel('mu')
f = pl.gcf()
samples = post[['mu', 'sigma', 'prob']].sample(n=10000, replace=True, weights=post.prob)
samples.plot.scatter(x='mu', y='sigma', alpha=0.1)
samples.plot.hexbin(x='mu', y='sigma', C='prob', cmap=cm.thermal);
samples.mu.plot.density()
samples.sigma.plot.density(color='orange')
d3 = d2.height.sample(n=20)
mu = np.linspace(150, 170, num=200)
prior_h = norm.rvs(sample_mu, sample_sigma, 1000)
sns.set_theme(style='darkgrid')
ax = sns.kdeplot(prior_h, bw=2)
ax.set(xlabel='height', title='Prior')
plt.show()
# code chunk 4.14 (grid estimation)
mu_grid = np.linspace(140, 160, 200)
sigma_grid = np.linspace(4, 9, 200)
post_list = [sum(norm.logpdf(d2, m, s)) for m in mu_grid for s in sigma_grid]
post_ll = np.concatenate(post_list, axis=0)
mu_grid_rep = np.repeat(mu_grid, 200)
sigma_grid_rep = np.tile(sigma_grid, 200)
len(post_ll) == len(mu_grid_rep) and len(post_ll) == len(sigma_grid_rep)
post_log_prob = post_ll + norm.logpdf(mu_grid_rep, 178, 20) + uniform.logpdf(
sigma_grid_rep, 0, 50)
post_prob = np.exp(post_log_prob - max(post_log_prob))
X, Y = np.meshgrid(mu_grid, sigma_grid)
Z = post_prob.reshape(200, 200)
plt.contour(X, Y, Z)
plt.show()
post_prob_std = post_prob / sum(post_prob)
sample_rows = np.random.choice(range(len(post_prob)),
size=1000,
replace=True,
p=post_prob_std)
sample_mu = mu_grid_rep[sample_rows]
sample_sigma = sigma_grid_rep[sample_rows]
plt.scatter(sample_mu, sample_sigma)
plt.show()
def negPost(x, *args):
y = args[0]
p = -1 * sum(norm.logpdf(y, x[0], x[1]))[0] + norm.logpdf(
x[0], 178, 20) + uniform.logpdf(x[1], 0, 50)
return p
def prior(a, b, sd):
aprior = uniform.logpdf(a, 0.0, 10.0)
bprior = norm.logpdf(b, 0.0, 5.0)
sdprior = uniform.logpdf(sd, 0.0, 30.0)
return (aprior + bprior + sdprior)
def _logp(self, value, lower, upper):
if value < lower or value > upper:
raise ValueError("Domain Error.")
return np.sum(uniform.logpdf(value, loc=lower, scale=upper-lower))
def joint_logprior(Om0=None,
Ob0=None,
Ol0=None,
q=None,
sigma80=None,
A=None,
X0=None,
B=None,
C0=None,
M0=None,
VX=None,
VC=None,
VM=None,
Om_a=0.01,
Om_b=0.99,
Ob_a=0.001,
Ob_b=0.4,
Ol_a=0.01,
Ol_b=0.99,
q_a=-1.5,
q_b=4.5,
Nq=None,
zbins=None,
Nscale=4,
bin_type='zunif',
xi0_lims=[5e-2, 2.0],
xi0=0.1,
**kwargs):
lp = 0.0
# Cosmological parameters
if Om0 is not None:
lp += uniform.logpdf(Om0, loc=Om_a, scale=Om_b - Om_a)
if Ob0 is not None:
lp += uniform.logpdf(Ob0, loc=Ob_a, scale=Ob_b - Ob_a)
if Ol0 is not None:
lp += uniform.logpdf(Ol0, loc=Ol_a, scale=Ol_b - Ol_a)
if sigma80 is not None:
lp += reciprocal.logpdf(sigma80, 1e-5, 1e+02)
# Nuisance parameters
if A is not None:
lp += uniform.logpdf(A, loc=0.0, scale=1.0)
if B is not None:
lp += uniform.logpdf(B, loc=0.0, scale=4.0)
if X0 is not None:
lp += norm.logpdf(X0, loc=0.0, scale=10.0)
if C0 is not None:
lp += norm.logpdf(C0, loc=0.0, scale=1.0)
if M0 is not None:
lp += norm.logpdf(M0, loc=-19.3, scale=2.0)
if VX is not None:
lp += reciprocal.logpdf(VX, 1e-10, 1e+04)
if VC is not None:
lp += reciprocal.logpdf(VC, 1e-10, 1e+04)
if VM is not None:
lp += reciprocal.logpdf(VM, 1e-10, 1e+04)
if q is not None: # one q par only
lp += uniform.logpdf(q, loc=q_a, scale=q_b - q_a)
# lp += norm.logpdf(q, loc=0.0, scale=0.3)
# Multiple correlated q pars from multivariate gaussian
if Nq is not None: # means multiple q pars
if Nq == 1:
lp += uniform.logpdf(kwargs['q1'], loc=q_a, scale=q_b - q_a)
return lp
qs = np.array([kwargs['q{}'.format(i + 1)]
for i in range(Nq)]) # extract q pars
# Pick one:
qmeans = smooth(qs, Nw=5) # fiducial
# qmeans = 0.0*qs
# Option 1: Hyperparameter dependent prior (unmarginalised)
# cov = cov_q(Nq, zbins, Nscale=Nscale, bin_type=bin_type, xi0=xi0_lims[0])
# lp += multivariate_normal.logpdf(qs, mean=qmeans, cov=cov)
# Option 2: Hyperparameter-marginalised prior
lp += np.log(
prior_q(qs,
zbins,
Nscale=Nscale,
bin_type=bin_type,
xi0_lims=xi0_lims,
qmeans=qmeans))
return lp
