def test_mixture_random_shape():
# test the shape broadcasting in mixture random
y = np.concatenate([nr.poisson(5, size=10), nr.poisson(9, size=10)])
with pm.Model() as m:
comp0 = pm.Poisson.dist(mu=np.ones(2))
w0 = pm.Dirichlet('w0', a=np.ones(2))
like0 = pm.Mixture('like0', w=w0, comp_dists=comp0, observed=y)
comp1 = pm.Poisson.dist(mu=np.ones((20, 2)), shape=(20, 2))
w1 = pm.Dirichlet('w1', a=np.ones(2))
like1 = pm.Mixture('like1', w=w1, comp_dists=comp1, observed=y)
comp2 = pm.Poisson.dist(mu=np.ones(2))
w2 = pm.Dirichlet('w2', a=np.ones(2), shape=(20, 2))
like2 = pm.Mixture('like2', w=w2, comp_dists=comp2, observed=y)
comp3 = pm.Poisson.dist(mu=np.ones(2), shape=(20, 2))
w3 = pm.Dirichlet('w3', a=np.ones(2), shape=(20, 2))
like3 = pm.Mixture('like3', w=w3, comp_dists=comp3, observed=y)
rand0, rand1, rand2, rand3 = draw_values([like0, like1, like2, like3],
point=m.test_point,
size=100)
assert rand0.shape == (100, 20)
assert rand1.shape == (100, 20)
assert rand2.shape == (100, 20)
assert rand3.shape == (100, 20)
with m:
ppc = pm.sample_posterior_predictive([m.test_point], samples=200)
assert ppc['like0'].shape == (200, 20)
assert ppc['like1'].shape == (200, 20)
assert ppc['like2'].shape == (200, 20)
assert ppc['like3'].shape == (200, 20)
def v2_model(observations,
nulls,
null_sd,
null_b,
null_dispersed_prob,
iter_count=2000,
tune_iters=2000):
with pm.Model() as model:
# Probability of being a DE gene
de_prob = pm.Beta('de_prob', alpha=1., beta=5.)
# Probability of being downregulated
down_prob = pm.Beta('down_prob', alpha=1., beta=1.)
dispersed_prob = null_dispersed_prob
mu_pos = pm.Lognormal('mu_pos', mu=-3, sd=1.)
mu_neg = pm.Lognormal('mu_neg', mu=-3, sd=1.)
sd_pos = pm.Gamma('sd_pos', alpha=0.01, beta=1.)
sd_neg = pm.Gamma('sd_neg', alpha=0.01, beta=1.)
nu_pos = pm.Gamma('nu_pos', alpha=5., beta=1.)
nu_neg = pm.Gamma('nu_neg', alpha=5., beta=1.)
spike_component = pm.Normal.dist(mu=0., sd=null_sd)
slab_component = pm.Laplace.dist(mu=0., b=null_b)
# Sample from Gaussian-Laplace mixture for null (spike-and-slab mixture)
pm.Mixture('null',
comp_dists=[spike_component, slab_component],
w=tt.as_tensor([1. - dispersed_prob, dispersed_prob]),
observed=nulls)
pos_component = pm.Bound(pm.StudentT, lower=0.).dist(mu=mu_pos,
sd=sd_pos,
nu=nu_pos)
neg_component = pm.Bound(pm.StudentT, upper=0.).dist(mu=-mu_neg,
sd=sd_neg,
nu=nu_neg)
pm.Mixture('obs',
w=tt.as_tensor([(1. - de_prob) * (1. - dispersed_prob),
(1. - de_prob) * dispersed_prob,
de_prob * (1. - down_prob),
de_prob * down_prob]),
comp_dists=[
spike_component, slab_component, pos_component,
neg_component
],
observed=observations)
pm.Deterministic('log_prob', model.logpt)
for RV in model.basic_RVs:
print(RV.name, RV.logp(model.test_point))
trace = pm.sample(iter_count, tune=tune_iters, chains=4)
ppc = pm.sample_ppc(trace, samples=iter_count, model=model)
return ({'trace': trace, 'ppc': ppc})
def test_mixture_random_shape():
# test the shape broadcasting in mixture random
y = np.concatenate([nr.poisson(5, size=10),
nr.poisson(9, size=10)])
with pm.Model() as m:
comp0 = pm.Poisson.dist(mu=np.ones(2))
w0 = pm.Dirichlet('w0', a=np.ones(2))
like0 = pm.Mixture('like0',
w=w0,
comp_dists=comp0,
shape=y.shape,
observed=y)
comp1 = pm.Poisson.dist(mu=np.ones((20, 2)),
shape=(20, 2))
w1 = pm.Dirichlet('w1', a=np.ones(2))
like1 = pm.Mixture('like1',
w=w1,
comp_dists=comp1, observed=y)
comp2 = pm.Poisson.dist(mu=np.ones(2))
w2 = pm.Dirichlet('w2',
a=np.ones(2),
shape=(20, 2))
like2 = pm.Mixture('like2',
w=w2,
comp_dists=comp2,
observed=y)
comp3 = pm.Poisson.dist(mu=np.ones(2),
shape=(20, 2))
w3 = pm.Dirichlet('w3',
a=np.ones(2),
shape=(20, 2))
like3 = pm.Mixture('like3',
w=w3,
comp_dists=comp3,
observed=y)
rand0 = like0.distribution.random(m.test_point, size=100)
assert rand0.shape == (100, 20)
rand1 = like1.distribution.random(m.test_point, size=100)
assert rand1.shape == (100, 20)
rand2 = like2.distribution.random(m.test_point, size=100)
assert rand2.shape == (100, 20)
rand3 = like3.distribution.random(m.test_point, size=100)
assert rand3.shape == (100, 20)
with m:
ppc = pm.sample_ppc([m.test_point], samples=200)
assert ppc['like0'].shape == (200, 20)
assert ppc['like1'].shape == (200, 20)
assert ppc['like2'].shape == (200, 20)
assert ppc['like3'].shape == (200, 20)
def main():
# Hyperparameters
n_flips = 125
n_coins = 10
n_draws = 5000
n_init_steps = 10000
n_burn_in_steps = 1000
# Create Causal Distribution
causal_probs = np.random.uniform(size=n_coins)
# Create Observations
X = np.array([
np.random.choice(2, p=[1 - p_, p_], size=n_flips)
for i, p_ in enumerate(causal_probs)
]).T
# Create Model
with pm.Model() as model:
ps = pm.Beta('probs', alpha=1, beta=1, shape=n_coins)
components = pm.Bernoulli.dist(p=ps, shape=n_coins)
w = pm.Dirichlet('w', a=np.ones(n_coins))
mix = pm.Mixture('mix', w=w, comp_dists=components, observed=X)
# Train Model
with model:
trace = pm.sample(n_draws, n_init=n_init_steps, tune=n_burn_in_steps)
# Display Results
pm.plot_trace(trace, var_names=['w', 'probs'])
plt.show()
pm.plot_posterior(trace, var_names=['w', 'probs'])
plt.show()
def nb_mixture(self, N=1000, tune=1000):
dat = np.asarray(self.data)
#kwargs = self.kwargs
#if len(kwargs) < 1:
# print("Missing args for nb mixture model estimation")
# sys.exit(2)
kwargs = self.kwargs
if len(kwargs) < 1:
print("missing args")
sys.exit(0)
print(np.max(dat))
with pm.Model() as model:
mu1 = pm.Uniform('mu1', lower=1, upper=self.mu)
mu2 = pm.Uniform('mu2', lower=1, upper=self.kwargs['mu2'])
alpha1 = pm.Uniform('alpha1', lower=0, upper=self.alpha)
alpha2 = pm.Uniform('alpha2', lower=0, upper=self.kwargs['alpha2'])
w = pm.Dirichlet('w', a=np.array([1, 1]))
nb1 = pm.NegativeBinomial.dist(mu=mu1, alpha=alpha1)
nb2 = pm.NegativeBinomial.dist(mu=mu2, alpha=alpha2)
like = pm.Mixture('like', w=w, comp_dists=[nb1, nb2], observed=dat)
trace_n = pm.sample(N, tune=tune, cores=2)
return trace_n
def create_model(self, Pm, pol_br_init, delta):
with pm.Model() as model:
#set priors for parameters
etal = pm.Normal("eta_l", mu=0, sigma=10)
etad = pm.HalfNormal("eta_d", sigma=2)
etah = pm.Deterministic("eta_h", etal + etad)
tauy = pm.HalfNormal("tau_y", sigma=2)
prg = pm.Uniform("prg", lower=self.qhigh, upper=1)
prb = pm.Uniform("prb", lower=0, upper=self.qlow)
etam = pm.Normal("etam", mu=0, sigma=10, shape=self.nm)
beta = pm.Normal("beta", mu=0, sigma=10)
#eqvars is a deterministic variable that computes the equilibrium and returns the stuff I need for the likelihood
eqvars = pm.Deterministic(
"eqvars",
self.eqinfo(etah, etal, tauy, prg, prb, etam, beta, Pm,
pol_br_init, delta))
peff = eqvars[0]
rvoteprob1 = eqvars[1]
rvoteprob2 = eqvars[2]
#compute initial voter beliefs
zdata = self.data['party_1'] * self.data['zr_1'] + (
1 - self.data['party_1']) * self.data['zd_1']
mu_top = pipardata * (prg**zdata) * (1 - prg)**(1 - zdata)
mu_bottom = mu_top + (1 - pipardata) * (prb**zdata) * (1 - prb)**(
1 - zdata)
mu = mu_top / mu_bottom
#mixture weights: [good type, bad type high effort, bad type low effort]
my_w = [mu, (1 - mu) * peff, (1 - mu) * (1 - peff)]
#component distributions (2-dimensional multivariate normals)
mvcomp1 = pm.MvNormal("ydist",
mu=[etah, etah],
cov=np.identity(3) * (tauy**(-2)),
shape=2)
mvcomp2 = pm.MvNormal("ydist",
mu=[etah, etal],
cov=np.identity(3) * (tauy**(-2)),
shape=2)
mvcomp3 = pm.MvNormal("ydist",
mu=[etal, etal],
cov=np.identity(3) * (tauy**(-2)),
shape=2)
#likelihood
Y_obs = pm.Mixture('Y',
w=my_w,
comp_dists=[mvcomp1, mccomp2, mccomp3],
observed=Y)
rvotes1 = pm.Binomial(n=self.data[rvotes_1] + self.data[dvotes_1],
p=rvoteprob1,
observed=self.data[rvotes_1])
rvotes2 = pm.Binomial(n=self.data[rvotes_2] + self.data[dvotes_2],
p=rvoteprob1,
observed=self.data[rvotes_2])
def get_model(self, vfield0, sigma_vfield0, rlim=1 * u.kpc):
# Number of prior mixture components:
with pm.Model() as model:
# True distance:
BoundedR = pm.Bound(UniformSpaceDensity,
lower=0,
upper=rlim.to_value(u.pc))
r = BoundedR("r", rlim.to_value(u.pc), shape=(self.N, 1))
# Milky Way velocity distribution
K = vfield0.shape[0]
w = pm.Dirichlet('w', a=np.ones(K))
# Set up means and variances:
meanvs = []
sigvs = []
for k in range(K):
vtmp = pm.Normal(f'vmean{k}', vfield0[k], 10., shape=3) # HACK
BoundedNormal = pm.Bound(pm.Normal, lower=1.5, upper=5.3)
lnstmp = BoundedNormal(f'lns{k}', np.log(sigma_vfield0[k]),
0.2)
stmp = pm.Deterministic(f'vsig{k}', tt.exp(lnstmp))
meanvs.append(vtmp)
sigvs.append(stmp)
pvdists = []
for k in range(K):
pvtmp = pm.MvNormal.dist(meanvs[k],
tau=np.eye(3) * 1 / sigvs[k]**2,
shape=3)
pvdists.append(pvtmp)
vxyz = pm.Mixture('vxyz',
w=w,
comp_dists=pvdists,
shape=(self.N, 3))
# Velocity in tangent plane coordinates
vtan = tt.batched_dot(self.Ms, vxyz)
model_pm = vtan[:, :2] / r * pc_mas_yr_per_km_s
model_rv = vtan[:, 2:3]
model_y = tt.concatenate((1000 / r, model_pm, model_rv), axis=1)
pm.Deterministic('model_y', model_y)
# val = pm.MvNormal('like', mu=model_y, tau=Cinv, observed=y)
dy = self.ys - model_y
pm.Potential(
'chisq',
-0.5 * tt.batched_dot(dy, tt.batched_dot(self.Cinvs, dy)))
return model
def build_model(data, K):
n_ppt = len(data)
print('Building model with n=%d,K=%d' % (n_ppt, K))
with pm.Model() as gmm:
#Prior
if K > 1:
p = pm.Dirichlet('p',
a=pm.floatX(np.array([1.] * K)),
testval=pm.floatX(np.ones(K) / K))
mus_p = [
pm.MvNormal('mu_%s' % pid,
mu=pm.floatX(np.zeros(2)),
tau=pm.floatX(0.1 * np.eye(2)),
shape=(K, 2)) for pi, pid in enumerate(data.keys())
]
packed_L = [[
pm.LKJCholeskyCov('packed_L_%s_%d' % (pid, i),
n=2,
eta=pm.floatX(2.),
sd_dist=pm.HalfCauchy.dist(.01))
for i in range(K)
] for pi, pid in enumerate(data.keys())]
L = [[
pm.expand_packed_triangular(2, packed_L[pi][i]) for i in range(K)
] for pi, pid in enumerate(data.keys())]
sigma = [[
pm.Deterministic('sigma_%s_%d' % (pid, i),
L[pi][i].dot(L[pi][i].T)) for i in range(K)
] for pi, pid in enumerate(data.keys())]
if K > 1:
mvnl = [[
pm.MvNormal.dist(mu=mus_p[pi][i], chol=L[pi][i])
for i in range(K)
] for pi in range(n_ppt)]
Y_obs = [
pm.Mixture('Y_obs_%s' % pid,
w=p,
comp_dists=mvnl[pi],
observed=data[pid])
for pi, pid in enumerate(data.keys())
]
else:
Y_obs = [
pm.MvNormal('Y_obs_%s' % pid,
mu=mus_p[pi][0],
chol=L[pi][0],
observed=data[pid])
for pi, pid in enumerate(data.keys())
]
return gmm
def test_sample_prior_and_posterior(self):
def build_toy_dataset(N, K):
pi = np.array([0.2, 0.5, 0.3])
mus = [[1, 1, 1], [-1, -1, -1], [2, -2, 0]]
stds = [[0.1, 0.1, 0.1], [0.1, 0.2, 0.2], [0.2, 0.3, 0.3]]
x = np.zeros((N, 3), dtype=np.float32)
y = np.zeros((N, ), dtype=np.int)
for n in range(N):
k = np.argmax(np.random.multinomial(1, pi))
x[n, :] = np.random.multivariate_normal(
mus[k], np.diag(stds[k]))
y[n] = k
return x, y
N = 100 # number of data points
K = 3 # number of mixture components
D = 3 # dimensionality of the data
X, y = build_toy_dataset(N, K)
with pm.Model() as model:
pi = pm.Dirichlet("pi", np.ones(K), shape=(K, ))
comp_dist = []
mu = []
packed_chol = []
chol = []
for i in range(K):
mu.append(pm.Normal("mu%i" % i, 0, 10, shape=D))
packed_chol.append(
pm.LKJCholeskyCov("chol_cov_%i" % i,
eta=2,
n=D,
sd_dist=pm.HalfNormal.dist(2.5)))
chol.append(
pm.expand_packed_triangular(D, packed_chol[i], lower=True))
comp_dist.append(
pm.MvNormal.dist(mu=mu[i], chol=chol[i], shape=D))
pm.Mixture("x_obs", pi, comp_dist, observed=X)
with model:
trace = pm.sample(30, tune=10, chains=1)
n_samples = 20
with model:
ppc = pm.sample_posterior_predictive(trace, n_samples)
prior = pm.sample_prior_predictive(samples=n_samples)
assert ppc["x_obs"].shape == (n_samples, ) + X.shape
assert prior["x_obs"].shape == (n_samples, ) + X.shape
assert prior["mu0"].shape == (n_samples, D)
assert prior["chol_cov_0"].shape == (n_samples, D * (D + 1) // 2)
def fit(self, y, yerr, x, gmm_params, sample_kwargs={}):
"""
yerr :
The uncertainties (standard deviations) in measured y.
"""
x = np.asarray(x)
y = np.asarray(y)
yerr = np.asarray(yerr)
# Left merge dictionary
default_sample_kwargs = dict(draws=1000, tune=1000, chains=2)
sample_kwargs = {**default_sample_kwargs, **sample_kwargs}
nsamples = y.shape[0]
assert gmm_params.shape[
1] % 3 == 0, "GMM params shape 1 must multiple of 3."
k = gmm_params.shape[1] // 3
mu_x = gmm_params[:, :k]
sigma_x = gmm_params[:, k:2 * k]
weights_x = gmm_params[:, 2 * k:3 * k]
with pm.Model() as model: # noqa
# Priors
intercept = pm.Uniform("intercept", -1, 1)
slope = pm.Uniform("slope", -1, 0)
scatter_sigma = pm.HalfNormal("scatter", 2)
components = []
for i in range(k):
component = pm.Normal.dist(mu=mu_x[:, i],
sigma=sigma_x[:, i],
shape=nsamples)
components.append(component)
x = pm.Mixture("x",
w=weights_x,
comp_dists=components,
shape=nsamples)
# Likelihoods
# Constant value for true y which served as the mean value of the observed y
y_true = pm.Deterministic("y_true", slope * x + intercept)
# Standard deviation of observed y as Gaussian errors
y_sigma = pm.Deterministic(
"sigma", pm.math.sqrt(yerr**2 + scatter_sigma**2))
# Altogether, observed y is normally distributed
y_ = pm.Normal("y", mu=y_true, sigma=y_sigma, observed=y)
trace = pm.sample(**sample_kwargs)
return trace, model
def level_model(y_old, y_new):
# PyMC3 level changepoint model
# level is modeled by Poisson RVs
# y_old: older data points since the last changepoint
# y_new: last win(10) datapoints
mean_new = y_new.mean() if len(y_new) > 0 else None
mean_old = y_old.mean() if len(y_old) > 0 else mean_new
y_ = np.concatenate((y_old, y_new))
y_obs = theano.shared(y_)
with pm.Model() as model:
w = pm.Dirichlet('w', a=np.ones(2))
lambda_ = pm.Exponential('lambda', lam=np.array([1.0 / mean_old, 1.0 / mean_new]), shape=(2,))
components = pm.Poisson.dist(mu=lambda_, shape=(2, ))
diff = pm.Deterministic('diff', lambda_[0] - lambda_[1])
obs = pm.Mixture('obs', w=w, comp_dists=components, observed=y_obs)
return model
def mixture_model(data):
with pm.Model() as model:
hyper_mean = pm.Uniform('hyper_mean', -100, 10)
hyper_mean1 = pm.Uniform('hyper_mean1', 100, 300)
hyper_sigma = pm.Uniform('hyper_sigma', 0, 100)
hyper_sigma1 = pm.Uniform('hyper_sigma1', 0, 150)
component = pm.Normal.dist(mu=hyper_mean, sd=hyper_sigma)
component1 = pm.Normal.dist(mu=hyper_mean1, sd=hyper_sigma1)
w = pm.Dirichlet('w', a=np.array([1, 1]))
like = pm.Mixture('like', w=w, comp_dists=[component, component1], observed=data)
with model:
trace = pm.sample(5000, tune=2500, njobs=1)[1000:]
def build_model(data, K):
N = data.shape[0]
d = data.shape[1]
print('Building model with n=%d, d=%d, k=%d' % (N, d, K))
with pm.Model() as gmm:
#Prior over component weights
if K > 1:
p = pm.Dirichlet('p', a=np.array([1.] * K))
#Prior over component means
mus = [
pm.MvNormal('mu_%d' % i,
mu=pm.floatX(np.zeros(d)),
tau=pm.floatX(0.1 * np.eye(d)),
shape=(d, ))
#testval = pm.floatX(np.ones(d)))
for i in range(K)
]
#Cholesky decomposed LKJ prior over component covariance matrices
packed_L = [
pm.LKJCholeskyCov('packed_L_%d' % i,
n=d,
eta=2.,
sd_dist=pm.HalfCauchy.dist(1))
#testval = pm.floatX(np.ones(int(d*(d-1)/2+d))))
for i in range(K)
]
#Unpack packed_L into full array
L = [pm.expand_packed_triangular(d, packed_L[i]) for i in range(K)]
#Convert L to sigma and tau for convenience
sigma = [
pm.Deterministic('sigma_%d' % i, L[i].dot(L[i].T))
for i in range(K)
]
tau = [
pm.Deterministic('tau_%d' % i, matrix_inverse(sigma[i]))
for i in range(K)
]
#Specify the likelihood
if K > 1:
mvnl = [pm.MvNormal.dist(mu=mus[i], chol=L[i]) for i in range(K)]
Y_obs = pm.Mixture('Y_obs', w=p, comp_dists=mvnl, observed=data)
else:
Y_obs = pm.MvNormal('Y_obs', mu=mus[0], chol=L[0], observed=data)
return gmm
def get_model():
conf = bayes_workshop.conf.get_conf()
(cols, data) = bayes_workshop.data.get_data()
demo_subj_id = 2
demo_modality = "visual"
i_demo_trials = np.logical_and(
data[:, cols.index("i_subj")] == demo_subj_id,
(data[:, cols.index("i_modality")]
== conf.modalities.index(demo_modality)))
demo_data = data[i_demo_trials, :]
(n_trials, _) = demo_data.shape
responses = demo_data[:, cols.index("target_longer")]
cmp_dur = demo_data[:, cols.index("target_duration")]
with pm.Model() as model:
alpha = pm.Normal("alpha", mu=conf.standard_ms, sd=50.0)
beta = pm.HalfNormal("beta", sd=100.0)
lapse_bias = pm.Uniform("psi", lower=0.0, upper=1.0)
# probability of lapsing on each trial
lapse_p = pm.Uniform("phi", lower=0.0, upper=1.0)
lapse_ind = pm.Bernoulli("lapse_ind", p=lapse_p, shape=n_trials)
theta_pf = bayes_workshop.utils.logistic(x=cmp_dur,
alpha=alpha,
beta=beta)
obs_pf = pm.Bernoulli.dist(p=theta_pf)
obs_lapse = pm.Bernoulli.dist(p=lapse_bias, shape=n_trials)
mix = pm.Mixture("obs",
w=tt.stack([1.0 - lapse_ind, lapse_ind], axis=1),
comp_dists=[obs_pf, obs_lapse],
observed=responses)
return model
def run_non_sparse_initialization(self):
rat = self.allelic_counts/self.total_counts
nans = np.isnan(rat)
# Run bb-mf
with pm.Model() as bb_glm:
CONC = pm.HalfCauchy('CONC', beta=5, shape=(1,self.S), testval=self.conc_init)
ALPHA = pm.HalfCauchy('ALPHA', beta=5, shape=(1, self.S))
BETA = pm.Normal('BETA', mu=0, tau=(1.0/10.0), shape=(self.S, self.num_cov), testval=self.beta_init)
U = pm.Normal('U', mu=0, tau=(1.0/1.0), shape=(self.N, self.K), testval=self.U_init)
V = pm.Normal('V', mu=0, tau=(1.0/1.0), shape=(self.S, self.K), testval=self.V_init)
MU_A = pm.Normal("MU_A", mu=0., sd=100**2, shape=(1,self.S), testval=self.mu_a_init)
SIGMA_A = pm.HalfCauchy("SIGMA_A", beta=5.0, shape=(1,self.S), testval=self.sigma_a_init)
mu_a_mat = pm.math.dot(np.ones((self.I,1)), MU_A)
sigma_a_mat = pm.math.dot(np.ones((self.I,1)), SIGMA_A)
A = pm.Normal('A', mu=mu_a_mat, sigma=sigma_a_mat, shape=(self.I,self.S), testval=self.A_init)
p = pm.math.invlogit(pm.math.dot(self.cov, BETA.T) + pm.math.dot(U,V.T) + A[self.Z,:])
conc_mat = pm.math.dot(np.ones((self.N,1)), CONC)
w = pm.Dirichlet('w', a=np.ones((self.S,2)))
beta_null_mat = pm.math.dot(np.ones((self.N,1)), ALPHA)
BB_GLM = pm.BetaBinomial.dist(alpha=(p*conc_mat), beta=((1.0-p)*conc_mat), n=self.total_counts)
BB_NULL = pm.BetaBinomial.dist(alpha=(np.ones((self.N,self.S))), beta=7.0+beta_null_mat, n=self.total_counts)
mixmod = pm.Mixture('mixmodel', w=w, comp_dists=[BB_GLM, BB_NULL], observed=self.allelic_counts, shape=2)
approx = pm.fit(method='advi', n=2000)
#pickle.dump(approx, open(self.output_root + '_model', 'wb'))
#approx = pickle.load( open(self.output_root + '_model', "rb" ) )
means_dict = approx.bij.rmap(approx.params[0].eval())
y = means_dict['w_stickbreaking__'].T
y = np.concatenate([y, -np.sum(y, 0, keepdims=True)])
e_y = np.exp(y - np.max(y, 0, keepdims=True))
w_learned = e_y / np.sum(e_y, 0, keepdims=True)
self.conc_init = np.exp(means_dict['CONC_log__'])
self.alpha_init = np.exp(means_dict['ALPHA_log__'])
self.beta_init = means_dict['BETA']
self.U_init = means_dict['U']
self.V_init = means_dict['V']
self.mu_a_init = means_dict['MU_A']
self.sigma_a_init = np.exp(means_dict['SIGMA_A_log__'])
self.A_init = means_dict['A']
self.w_init = w_learned.T
def run_factorization(self):
rat = self.allelic_counts/self.total_counts
nans = np.isnan(rat)
# Run bb-mf
with pm.Model() as bb_glm:
CONC = pm.HalfCauchy('CONC', beta=5, shape=(1,self.S), testval=self.conc_init)
ALPHA = pm.HalfCauchy('ALPHA', beta=5, shape=(1, self.S), testval=self.alpha_init)
BETA = pm.Normal('BETA', mu=0, tau=(1.0/10.0), shape=(self.S, self.num_cov), testval=self.beta_init)
gamma = pm.HalfCauchy('GAMMA', beta=5, shape=(self.N, self.K), testval=np.ones((self.N, self.K)))
U = pm.Normal('U', mu=0, sigma=1.0/gamma, shape=(self.N, self.K), testval=self.U_init)
V = pm.Normal('V', mu=0, tau=(1.0/1.0), shape=(self.S, self.K), testval=self.V_init)
MU_A = pm.Normal("MU_A", mu=0., sd=100**2, shape=(1,self.S), testval=self.mu_a_init)
SIGMA_A = pm.HalfCauchy("SIGMA_A", beta=5.0, shape=(1,self.S), testval=self.sigma_a_init)
mu_a_mat = pm.math.dot(np.ones((self.I,1)), MU_A)
sigma_a_mat = pm.math.dot(np.ones((self.I,1)), SIGMA_A)
A = pm.Normal('A', mu=mu_a_mat, sigma=sigma_a_mat, shape=(self.I,self.S), testval=self.A_init)
p = pm.math.invlogit(pm.math.dot(self.cov, BETA.T) + pm.math.dot(U,V.T) + A[self.Z,:])
conc_mat = pm.math.dot(np.ones((self.N,1)), CONC)
w = pm.Dirichlet('w', a=np.ones((self.S,2)), testval=self.w_init)
beta_null_mat = pm.math.dot(np.ones((self.N,1)), ALPHA)
BB_GLM = pm.BetaBinomial.dist(alpha=(p*conc_mat), beta=((1.0-p)*conc_mat), n=self.total_counts)
BB_NULL = pm.BetaBinomial.dist(alpha=(np.ones((self.N,self.S))), beta=7.0+beta_null_mat, n=self.total_counts)
mixmod = pm.Mixture('mixmodel', w=w, comp_dists=[BB_GLM, BB_NULL], observed=self.allelic_counts, shape=2)
approx = pm.fit(method='advi', n=30000)
#pickle.dump(approx, open(self.output_root + '_model', 'wb'))
#approx = pickle.load( open(self.output_root + '_model', "rb" ) )
means_dict = approx.bij.rmap(approx.params[0].eval())
np.savetxt(self.output_root + '_temper_U.txt', (means_dict['U']), fmt="%s", delimiter='\t')
np.savetxt(self.output_root + '_temper_V.txt', (means_dict['V'].T), fmt="%s", delimiter='\t')
np.savetxt(self.output_root + '_temper_BETA.txt', (means_dict['BETA'].T), fmt="%s", delimiter='\t')
np.savetxt(self.output_root + '_temper_ALPHA.txt', (np.exp(means_dict['ALPHA_log__'])), fmt="%s", delimiter='\t')
np.savetxt(self.output_root + '_temper_GAMMA.txt', (np.exp(means_dict['GAMMA_log__'])), fmt="%s", delimiter='\t')
np.savetxt(self.output_root + '_temper_CONC.txt', (np.exp(means_dict['CONC_log__'])), fmt="%s", delimiter='\t')
np.savetxt(self.output_root + '_temper_w_stick_breaking.txt', (np.exp(means_dict['w_stickbreaking__'])), fmt="%s", delimiter='\t')
np.savetxt(self.output_root + '_temper_ELBO.txt', (approx.hist), fmt="%s", delimiter='\t')
def run_null_model(nulls, iter_count=2000, tune_iters=2000):
with pm.Model() as model:
sd_null = pm.Gamma('sd_null', alpha=.1, beta=1.)
b_null = pm.Gamma('b_null', alpha=1., beta=.1)
dispersed_prob = pm.Beta('dispersed_prob', alpha=1., beta=1.)
pm.Mixture('null',
comp_dists=[
pm.Normal.dist(mu=0., sd=sd_null),
pm.Laplace.dist(mu=0., b=b_null)
],
w=tt.as_tensor([1. - dispersed_prob, dispersed_prob]),
observed=nulls)
pm.Deterministic('log_prob', model.logpt)
trace = pm.sample(iter_count, tune=tune_iters, chains=4)
ppc = pm.sample_ppc(trace, samples=iter_count, model=model)
return ({'trace': trace, 'ppc': ppc})
def _model_eval(self, X, K, n_samples):
# setup model
with pm.Model() as model:
data_dim = X.shape[1]
# prior of mixture ratio
w = pm.Dirichlet('w', a=np.ones(K))
# setup the likelihood
init_mu = np.zeros(data_dim)
components = [
self._multivariate_normal_dist(init_mu, suffix=k)
for k in range(K)
]
like = pm.Mixture('like', w=w, comp_dists=components, observed=X)
# fit model
with model:
trace = pm.sample(2000,
step=pm.NUTS(),
start=pm.find_MAP(),
tune=1000)
# store the result
self.result['K=' + str(K)] = trace
#定义stick_breaking过程
def stick_breaking(beta):
portion_remaining = tt.concatenate([[1], tt.extra_ops.cumprod(1 - beta)[:-1]])
return beta * portion_remaining
with pm.Model() as model:
M=pm.Gamma('M',1.,1.)
sigma=pm.Uniform('sigma',0.,1.)
mu1=pm.Normal('mu',0.,1.)
xi=pm.InverseGamma('xi',1.,1.)
b=pm.Normal('b',0.,xi,shape=N)
sigma_w=pm.Uniform('sigma_w',0.,1.,shape=K)
rho=pm.Uniform('rho',0.,1.,shape=K)
beta=pm.Beta('beta',1.,M,shape=K)
w=pm.Deterministic('w',stick_breaking(beta))
omega=pm.Mixture('omega',w,pm.MvNormal.dist(mu=mu0,cov=sigma_w[:,np.newaxis,np.newaxis]**2*H(rho)))
obs=pm.MvNormal('obs',mu=(mu1+b)*e+omega,cov=sigma**2*I,observed=dataSet1)
# Convert L to sigma for convenience
sigma = [[
pm.Deterministic('sigma_%d_%d' % (pid, i),
L[pi][i].dot(L[pi][i].T)) for i in range(k)
] for pi, pid in enumerate(data.keys())]
# Specify the likelihood
if k > 1:
mvnl = [[
pm.MvNormal.dist(mu=mus_p[pi][i], chol=L[pi][i])
for i in range(k)
] for pi in range(n_ppt)]
Y_obs = [
pm.Mixture('Y_obs_%d' % pid,
w=p,
comp_dists=mvnl[pi],
observed=data[pid])
for pi, pid in enumerate(data.keys())
]
else:
Y_obs = [
pm.MvNormal('Y_obs_%d' % pid,
mu=mus_p[pi][0],
chol=L[pi][0],
observed=data[pid])
for pi, pid in enumerate(data.keys())
]
## Run sampler
# Initialize list of traces
traces = []
def _multivariate_normal_prior(self, key):
"""
Map the bilby MultivariateNormal prior to a PyMC3 style function.
"""
# check prior is a PowerLaw
pymc3, STEP_METHODS, floatX = self._import_external_sampler()
theano, tt, as_op = self._import_theano()
if isinstance(self.priors[key], MultivariateGaussian):
# get names of multivariate Gaussian parameters
mvpars = self.priors[key].mvg.names
# set the prior on multiple parameters if not present yet
if not np.all([p in self.multivariate_normal_sets for p in mvpars]):
mvg = self.priors[key].mvg
# get bounds
lower = [bound[0] for bound in mvg.bounds.values()]
upper = [bound[1] for bound in mvg.bounds.values()]
# test values required for mixture
testvals = []
for bound in mvg.bounds.values():
if np.isinf(bound[0]) and np.isinf(bound[1]):
testvals.append(0.)
elif np.isinf(bound[0]):
testvals.append(bound[1] - 1.)
elif np.isinf(bound[1]):
testvals.append(bound[0] + 1.)
else:
# half-way between the two bounds
testvals.append(bound[0] + (bound[1] - bound[0]) / 2.)
# if bounds are at +/-infinity set to 100 sigmas as infinities
# cause problems for the Bound class
maxmu = np.max(mvg.mus, axis=0)
minmu = np.min(mvg.mus, axis=0)
maxsigma = np.max(mvg.sigmas, axis=0)
for i in range(len(mvpars)):
if np.isinf(lower[i]):
lower[i] = minmu[i] - 100. * maxsigma[i]
if np.isinf(upper[i]):
upper[i] = maxmu[i] + 100. * maxsigma[i]
# create a bounded MultivariateNormal distribution
BoundedMvN = pymc3.Bound(pymc3.MvNormal, lower=lower, upper=upper)
comp_dists = [] # list of any component modes
for i in range(mvg.nmodes):
comp_dists.append(BoundedMvN('comp{}'.format(i), mu=mvg.mus[i],
cov=mvg.covs[i],
shape=len(mvpars)).distribution)
# create a Mixture model
setname = 'mixture{}'.format(self.multivariate_normal_num_sets)
mix = pymc3.Mixture(setname, w=mvg.weights, comp_dists=comp_dists,
shape=len(mvpars), testval=testvals)
for i, p in enumerate(mvpars):
self.multivariate_normal_sets[p] = {}
self.multivariate_normal_sets[p]['prior'] = mix[i]
self.multivariate_normal_sets[p]['set'] = setname
self.multivariate_normal_sets[p]['index'] = i
self.multivariate_normal_num_sets += 1
# return required parameter
return self.multivariate_normal_sets[key]['prior']
else:
raise ValueError("Prior for '{}' is not a MultivariateGaussian".format(key))
def sample(self, name_chain, noncentered=False):
"""
Sample from the hierarchical model
p(mu) ~ U(0,1)
p(phi) ~ U(0,pi)
p(muB) ~ U(0.0, 1.0)
p(muC) ~ U(0.0, 1.0)
p(sigmaB) ~ HN(sd=1)
p(sigmaC) ~ HN(sd=1)
p(B|muB,sigmaB) ~ BoundedNormal(mu=muB, sd=sigmaB, lower=0, upper=1)
p(C|muC,sigmaC) ~ BoundedNormal(mu=muC, sd=sigmaC, lower=0, upper=1)
qobs ~ N(mu=q, sd=noise)
q = f(B,C,mu,phi)
"""
self.name_chain = name_chain
A = 1.0
# Define the probabilistic model
self.model = pm.Model()
with self.model:
# Priors for orientation
mu = pm.Uniform('mu',
lower=0,
upper=1.0,
testval=0.5,
shape=self.n_galaxies)
phi = pm.Uniform('phi',
lower=0,
upper=np.pi / 2.0,
testval=0.1,
shape=self.n_galaxies)
# Priors for means and standard deviations. Perhaps one should play a little with the
# priors for sdB and sdC because they are usually not very well constrained by data
muCB_ = pm.Uniform('muCB_',
lower=0.0,
upper=1.0,
testval=[0.3, 0.8],
shape=2)
muCB = pm.Deterministic('muCB', tt.sort(muCB_))
muCB2_ = pm.Uniform('muCB2_',
lower=0.0,
upper=1.0,
testval=[0.3, 0.8],
shape=2)
muCB2 = pm.Deterministic('muCB2', tt.sort(muCB2_))
sdCB = pm.HalfNormal('sdCB', sd=0.05, shape=2)
sdCB2 = pm.HalfNormal('sdCB2', sd=0.05, shape=2)
w = pm.Dirichlet('w', np.ones(2))
# Use a non-centered model (http://twiecki.github.io/blog/2017/02/08/bayesian-hierchical-non-centered/)
if (noncentered):
offset = pm.Normal('offset',
mu=0,
sd=1,
shape=(self.n_galaxies, 2))
CB_ = pm.Deterministic('CB_',
tt.clip(muCB + offset * sdCB, 0.0, 1.0))
CB = pm.Deterministic('CB', tt.sort(CB_, axis=1))
else:
bounded_normal = pm.Bound(pm.Normal, lower=0.0, upper=1.0)
CB_ = bounded_normal.dist('CB_',
mu=muCB,
sd=sdCB,
testval=np.array([0.3, 0.8]),
shape=(self.n_galaxies, 2))
CB2_ = bounded_normal.dist('CB2_',
mu=muCB2,
sd=sdCB2,
testval=np.array([0.3, 0.8]),
shape=(self.n_galaxies, 2))
comp_dists = [CB_, CB2_]
mix = pm.Mixture('mix',
w=w,
comp_dists=comp_dists,
testval=np.array([0.3, 0.8]),
shape=(self.n_galaxies, 2))
CB = pm.Deterministic('CB', tt.sort(mix, axis=1))
# Now that we have all ingredients, compute q
# sin_theta = tt.sqrt(1.0 - mu**2)
# f = ( A*CB[:,0]*sin_theta*tt.cos(phi) )**2 + ( CB[:,1]*CB[:,0]*sin_theta*tt.sin(phi) )**2 + ( A*CB[:,1]*mu )**2
# g = A*A * (tt.cos(phi)**2 + mu**2 * tt.sin(phi)**2) + \
# CB[:,1]*CB[:,1] * (tt.sin(phi)**2 + mu**2 * tt.cos(phi)**2) + CB[:,0]*CB[:,0] * sin_theta**2
# h = tt.sqrt( (g - 2 * tt.sqrt(f)) / (g + 2 * tt.sqrt(f)) )
# q = (1 - h) / (1 + h)
# # And define the normal likelihood
# qobs = pm.Normal('qobs', mu=q, sd=self.sigmaq, observed=self.qobs, shape=self.n_galaxies)
# Finally sample from the posterior and use a CSV backend for later plots
db = pm.backends.Text(self.name_chain)
self.trace = pm.sample(chains=4, trace=db)
self.ppc = pm.sample_ppc(self.trace,
samples=500,
model=self.model,
size=100)
testval=0) - 1
# --- Raters ability to detect true spindles --- #
# rater_expertise = pm.Bound(pm.Normal, lower=0.)('rater_expertise',
# mu=expected_std_for_accuracy,
# sd=0.3,
# shape=n_raters)
# --- Observed behaviour --- #
# Spindle start when marker is real
mapping = mapping_marker_to_true_spindle[data['t']]
spindle_real = pm.Normal.dist(mu=tss[mapping],
sd=1) #rater_expertise[data['rater_i']])
contaminate_spindle_start.mean = 12.5 # hack, https://discourse.pymc.io/t/how-to-use-a-densitydist-in-a-mixture/1371/2
spindle_real.mean = 12.5
obs_start = pm.Mixture(
'marker_start',
w=marker_is_from_real_spindle_stacked,
comp_dists=[spindle_real, contaminate_spindle_start],
observed=data['s'])
with model:
trace = pm.sample(tune=1000,
init="adapt_diag",
nuts_kwargs={
'target_accept': 0.99
}) # turn off jitter so we dont break ordering gss
pm.traceplot(trace)
plt.show()
print(pm.summary(trace))
def splatter_model(observations,
nulls,
null_sd,
null_b,
null_dispersed_prob,
iter_count=2000,
tune_iters=2000):
with pm.Model() as model:
# Probability of being a DE gene
de_prob = pm.Uniform('de_prob', lower=0., upper=1.)
# Probability of being downregulated
down_prob = pm.Beta('down_prob', alpha=1., beta=1.)
# Mean and sd for Gaussian for DE genes
mu_pos = pm.Lognormal('mu_pos', mu=0., sd=1.)
mu_neg = pm.Lognormal('mu_neg', mu=0., sd=1.)
sd_pos = pm.Gamma('sd_pos', alpha=1., beta=1.)
sd_neg = pm.Gamma('sd_neg', alpha=1., beta=1.)
dispersed_prob = null_dispersed_prob
spike_component = pm.Normal.dist(mu=0., sd=null_sd)
slab_component = pm.Laplace.dist(mu=0., b=null_b)
# Sample from Gaussian-Laplace mixture for null (spike-and-slab mixture)
pm.Mixture('null',
comp_dists=[spike_component, slab_component],
w=tt.as_tensor([1. - dispersed_prob, dispersed_prob]),
observed=nulls)
pos_component = pm.Bound(pm.Normal, lower=0.).dist(mu=mu_pos,
sd=sd_pos)
neg_component = pm.Bound(pm.Normal, upper=0.).dist(mu=-1 * mu_neg,
sd=sd_neg)
pos_component_abs = pm.Bound(pm.Normal, lower=0.).dist(mu=-1 * mu_pos,
sd=sd_pos)
neg_component_abs = pm.Bound(pm.Normal, upper=0.).dist(mu=mu_neg,
sd=sd_neg)
cdf_pos = cdf(mu=mu_pos, sd=sd_pos, value=0.)
cdf_neg = cdf(mu=-1 * mu_neg, sd=sd_neg, value=0.)
pm.Mixture('obs',
w=tt.as_tensor([(1. - de_prob) * (1. - dispersed_prob),
(1. - de_prob) * dispersed_prob,
de_prob * (1. - down_prob) * (1. - cdf_pos),
de_prob * down_prob * cdf_neg,
de_prob * (1. - down_prob) * cdf_pos,
de_prob * down_prob * (1. - cdf_neg)]),
comp_dists=[
spike_component, slab_component, pos_component,
neg_component, pos_component_abs, neg_component_abs
],
observed=observations)
pm.Deterministic('log_prob', model.logpt)
trace = pm.sample(iter_count, tune=tune_iters, chains=4)
ppc = pm.sample_ppc(trace, samples=iter_count, model=model)
return ({'trace': trace, 'ppc': ppc})
comp_dist = []
mu = []
packed_chol = []
chol = []
for i in range(K):
temp_mean = np.random.randint(low=50, high=200, size=D)
mu.append(pm.Normal('mu%i' % i, temp_mean, 20, shape=D))
packed_chol.append(
pm.LKJCholeskyCov('chol_cov_%i' % i,
eta=2,
n=D,
sd_dist=pm.HalfNormal.dist(10)))
chol.append(pm.expand_packed_triangular(D, packed_chol[i], lower=True))
comp_dist.append(pm.MvNormal.dist(mu=mu[i], chol=chol[i]))
xobs = pm.Mixture('x_obs', pi, comp_dist, observed=X_shared)
print("making inference...")
# Inference
with model:
advi_mf = pm.ADVI()
advi_mf.fit(10000,
more_replacements={X_shared: X_minibatch},
obj_optimizer=pm.adagrad(learning_rate=1e-2))
fig = plt.figure()
plt.plot(advi_mf.hist)
plt.title("loss function")
plt.savefig(out_path + "/" + "lossPlot.jpg")
print("making prediction...")
def main():
dsNum, dType = 1, "isNat"
inDir = os.environ['LATDIR'] + '/data/MCMC'
df = pd.read_hdf('{}/DS{}_Spectrum_{}.h5'.format(inDir, dsNum, dType))
dfTrit = pd.read_hdf('{}/TritSpec.h5'.format(inDir))
Y = df['Energy'].values
# Some values are negative (because Steve) so we need to fix it
# Also skip some values because who needs them?
Tritium = dfTrit['Tritium'].values[1::2]
Tritium = np.array([x if x >= 0. else 0. for x in Tritium])
Energy = dfTrit['Energy'].values[1::2]
# Efficiencies -- not implemented yet
# dfEff = pd.read_hdf('{}/DS{}_{}_Efficiency.h5'.format(inDir, dsNum, dType))
# XEff = dfEff['Energy'].values
# YEff = dfEff['Efficiency'].values
# Peak means
meansList = [6.54, 8.98, 10.37, 46.54]
sdList = [GetSigma(mean, dsNum) for mean in meansList]
with pm.Model() as model:
Fe55 = pm.Normal.dist(mu=meansList[0], sd=sdList[0])
Zn65 = pm.Normal.dist(mu=meansList[1], sd=sdList[1])
Ge68 = pm.Normal.dist(mu=meansList[2], sd=sdList[2])
Pb210 = pm.Normal.dist(mu=meansList[3], sd=sdList[3])
Bkg = pm.Uniform.dist(lower=2., upper=50.)
Tritium = pm.Interpolated("Tritium",
x_points=Energy,
pdf_points=Tritium,
testval=5.)
weights = pm.Dirichlet('weights', a=np.ones(len(meansList) + 2))
Mu = pm.Normal('Mu', mu=0.77, sd=0.1)
Sig = pm.Normal('Sig', mu=0.56, sd=0.1)
eff = LogisticFunc("Efficiency", mu=Mu, sd=Sig, testval=5.)
TritEff = Tritium * eff
mix = pm.Mixture('mix',
w=weights,
comp_dists=[Fe55, Zn65, Ge68, Pb210, TritEff, Bkg],
testval=5.)
# mix = pm.Mixture('mix', w=weights, comp_dists=[Fe55, Zn65, Ge68, Pb210, Tritium, Bkg], testval=5., observed=Y)
with model:
trace = pm.sample(draws=10000, n_init=2000, tune=2000)
pm.traceplot(trace)
print(pm.summary(trace))
# ppc = pm.sample_ppc(trace, samples=500, model=model, size=100)
# print(np.asarray(ppc['weights']).shape)
# _, ax = plt.subplots(figsize=(12, 6))
# ax.hist([n.mean() for n in ppc['n']], bins=19, alpha=0.5)
# ax.axvline(df['Energy'].mean())
# ax.set(title='Posterior predictive of the mean', xlabel='mean(x)', ylabel='Frequency');
plt.show()
def contaminate_mixture(data, fit_for='z', fit_data=None): #stickbreaking problems
steps = []
# shapes and sizes
n_epochs = data['epoch_i'].max() + 1 # each epoch indexed by epoch_i
n_raters = data['rater_i'].max() + 1
n_obs = data.shape[0] # each spindle marker indexed by t
# static priors vars
trust_purcell = 0.1 # crank up to give more weight to purcell et al, 2017
purcell = np.array([0.3587, 0.6387, 0.0026, 0., 0., 0.]) + (1 - trust_purcell)
s_number_prior = purcell / purcell.sum()
max_s = len(s_number_prior) - 1
gss_spindle_testvals = [1., 5., 10., 15., 20.]
with pm.Model() as model:
# True s
gss = pm.Uniform('gss', lower=0., upper=25., shape=(n_epochs, max_s),
testval=np.tile(np.array(gss_spindle_testvals).T, reps=(n_epochs, 1),)) # Real spindles
gss_per_obs = gss[data['epoch_i'], :]
# The number of spindles per epoch:
if fit_for == 'z':
gss_prior = pm.Dirichlet('gss_prior', a=s_number_prior)
if n_epochs > 1:
z = pm.Categorical('z', p=gss_prior,
shape=n_epochs)
else:
z = pm.Categorical('z', p=gss_prior)
else:
z = fit_data['z']
z_rs = z.reshape((n_epochs, 1))
if fit_for in ['w', 'z']: # when we are finding z or w
w_prior_possibilities = tt.tril(tt.ones((max_s + 1, max_s + 1)))
w = pm.Categorical('w', p=w_prior_possibilities[z_rs[data['epoch_i'], 0], :], shape=n_obs)
else: # fit for gss
w = fit_data['w']
# --- Raters ability to detect markers --- #
r_E = pm.Bound(pm.Normal, lower=0.)('r_E', mu=0.5, sd=0.5, shape=n_raters)
r_E_per_obs = r_E[data['rater_i']]
#r_E = pm.Bound(pm.Normal, lower=0.)('r_E', mu=0.5, sd=0.5)
# --- Behaviour --- #
contaminate_dist_s = pm.Uniform.dist(lower=0., upper=25., shape=n_obs)
contaminate_dist_s.mean = 12.5
possible_dists = [contaminate_dist_s]
for i in range(0, 5):
dist = pm.Normal.dist(mu=gss_per_obs[:, i], sd=r_E_per_obs)
dist.mean = gss_spindle_testvals[i]
possible_dists.append(dist)
w_array = tt.extra_ops.to_one_hot(w, nb_class=max_s + 1)
s = pm.Mixture('s', w=w_array,
comp_dists=possible_dists,
observed=data['s'])
#STEP methods for vars:
if fit_for == 'z':
steps = [pm.CategoricalGibbsMetropolis([z, w]),
pm.NUTS([gss_prior, gss, r_E], target_accept=0.9)]
if fit_for == 'w':
steps = [pm.CategoricalGibbsMetropolis([w]),
pm.NUTS([gss, r_E], target_accept=0.9)]
#else, everything NUTS
return model, steps
def _make_model(self):
pca = self.pca
mCounts = np.int_(self.counts * self.seq_depth_factor)
n_dim = pca.n_components_
n_modes = self.n_modes
n_samp = mCounts.shape[1]
n_features = mCounts.shape[0]
if self.kmeansInit:
sd_factor = 2 / n_modes
else:
sd_factor = 2
print("Defining model constants...")
if pca.whiten:
rot = np.sqrt(pca.explained_variance_[:, None]) * pca.components_
rot = theano.shared(floatX(rot))
cSd = floatX(1)
tcov = np.eye(n_dim)[np.tril_indices(n_dim)] * sd_factor
else:
rot = theano.shared(floatX(pca.components_))
cSd = floatX(np.sqrt(pca.explained_variance_))
tcov = (np.diag(pca.explained_variance_)[np.tril_indices(n_dim)] *
sd_factor)
shift = theano.shared(floatX(pca.mean_[None, :]),
broadcastable=(True, False))
multiNn = np.sum(mCounts, axis=0)
print("Counts shape:")
print(mCounts.shape)
lcounts = floatX(self.pca.transform(self.tau_log_E_p))
print("Latent counts shape:")
print(lcounts.shape)
high_tumor = self.pheno["tcEst"] > 0.8
low_tumor = self.pheno["tcEst"] < 0.2
if self.kmeansInit:
km = KMeans(n_clusters=n_modes,
random_state=0,
tol=1e-10,
max_iter=100)
mus_tumor = km.fit(lcounts[high_tumor, :]).cluster_centers_
mus_free = km.fit(lcounts[low_tumor, :]).cluster_centers_
else:
mus_tumor = np.repeat(np.mean(lcounts[high_tumor, :],
axis=0)[None, :],
10,
axis=0)
mus_free = np.repeat(np.mean(lcounts[low_tumor, :],
axis=0)[None, :],
10,
axis=0)
mus_tumor = floatX(mus_tumor)
mus_free = floatX(mus_free)
try:
chol_tumor = floatX(
np.linalg.cholesky(np.cov(lcounts[high_tumor, :].T)))
chol_tumor = chol_tumor[np.tril_indices(n_dim)] * sd_factor
except np.linalg.LinAlgError:
print(
"Seems we have to few HIGH tumor content samples to infer a starting covariance."
)
chol_tumor = tcov
try:
chol_free = floatX(
np.linalg.cholesky(np.cov(lcounts[low_tumor, :].T)))
chol_free = chol_free[np.tril_indices(n_dim)] * sd_factor
except np.linalg.LinAlgError:
print(
"Seems we have to few LOW tumor content samples to infer a starting covariance."
)
chol_free = tcov
md = self.tau_log_E_p - pca.mean_[None, :]
dev = md - np.dot(np.dot(md, pca.components_.T), pca.components_)
dev_std = np.std(dev, axis=0)
dev_mean = np.mean(dev, axis=0)
if self.no_deviations is True:
dev_f = dev_t = None
else:
dev_f = dev_t = theano.shared(floatX(dev))
p_f = floatX(self.p_f)
p_t = floatX(self.p_t)
sparsity = floatX(1)
n = floatX(self.pheno["tcRes"].values[:, None] * self.res_scale)
tc = floatX(self.pheno["tcEst"].values[:, None])
lb = floatX(1 - p_f)
ub = floatX(p_t)
padding = 1e-1 * (ub - lb)
pa_start = ((n * tc) + 1) / (n + 2)
pa_start = np.where(pa_start < lb, lb + padding, pa_start)
pa_start = np.where(pa_start > ub, ub - padding, pa_start)
pa_start = floatX(pa_start)
def inverse_pca(X):
return pm.math.dot(X, rot) + shift
def pa2alpha(p_a):
return (p_a + p_f - 1) / (p_t + p_f - 1)
def alpha2pa(alpha):
return (alpha * (p_t + p_f - 1)) - p_f + 1
def mixSep(x_f, x_t, alpha, dev_f, dev_t):
exp_f = inverse_pca(x_f)
exp_t = inverse_pca(x_t)
if dev_f is not None:
exp_f += dev_f
if dev_t is not None:
exp_t += dev_t
exp_f = tt.nnet.softmax(exp_f)
exp_t = tt.nnet.softmax(exp_t)
result = ((1 - alpha) * exp_f) + (alpha * exp_t)
return result
print("Making model...")
with pm.Model() as model:
# bounds with nummerical padding
p_a = pm.Beta(
"p_a",
alpha=floatX((n * tc) + 1),
beta=floatX((n * (1 - tc)) + 1),
transform=pm.distributions.transforms.Interval(lb, ub),
shape=(n_samp, 1),
testval=pa_start,
)
alpha = pm.Deterministic("alpha", pa2alpha(p_a))
sdd = pm.HalfNormal.dist(sd=cSd * self.relax_prior)
x_f_comps = list()
for i in range(n_modes):
mus_f = pm.Normal(
"mus_f_{}".format(i),
mu=0,
sd=cSd * self.relax_prior,
shape=n_dim,
testval=mus_free[i, :],
)
packed_L_f = pm.LKJCholeskyCov(
"packed_L_f_{}".format(i),
n=n_dim,
eta=sparsity,
sd_dist=sdd,
testval=chol_free,
)
chol_f = pm.expand_packed_triangular(n_dim,
packed_L_f,
lower=True)
x_f_comps.append(
pm.MvNormal.dist(mu=mus_f,
chol=chol_f,
shape=(n_samp, n_dim)))
if n_modes > 1:
w_f = pm.Dirichlet("w_f",
a=np.ones(n_modes) * self.dirichlet_prior)
x_f = pm.Mixture(
"x_f",
w=w_f,
comp_dists=x_f_comps,
shape=(n_samp, n_dim),
testval=lcounts,
)
else:
x_f = pm.MvNormal("x_f",
mu=mus_f,
chol=chol_f,
shape=(n_samp, n_dim))
if self.same_kernels:
x_t_comps = x_f_comps
else:
x_t_comps = list()
for i in range(n_modes):
mus_t = pm.Normal(
"mus_t_{}".format(i),
mu=0,
sd=cSd * self.relax_prior,
shape=n_dim,
testval=mus_tumor[i, :],
)
packed_L_t = pm.LKJCholeskyCov(
"packed_L_t_{}".format(i),
n=n_dim,
eta=sparsity,
sd_dist=sdd,
testval=chol_tumor,
)
chol_t = pm.expand_packed_triangular(n_dim,
packed_L_t,
lower=True)
x_t_comps.append(
pm.MvNormal.dist(mu=mus_t,
chol=chol_t,
shape=(n_samp, n_dim)))
if n_modes > 1:
w_t = pm.Dirichlet("w_t",
a=np.ones(n_modes) * self.dirichlet_prior)
x_t = pm.Mixture(
"x_t",
w=w_t,
comp_dists=x_t_comps,
shape=(n_samp, n_dim),
testval=lcounts,
)
else:
x_t = pm.MvNormal("x_t",
mu=mus_t,
chol=chol_t,
shape=(n_samp, n_dim))
if self.sample_deviation is True:
dev_f = pm.Normal(
"dev_f",
mu=dev_mean,
sigma=dev_std,
shape=(n_samp, n_features),
testval=dev,
)
dev_t = pm.Normal(
"dev_t",
mu=dev_mean,
sigma=dev_std,
shape=(n_samp, n_features),
testval=dev,
)
if self.hazard_model == "cox":
b = pm.Normal("logHR", mu=0, sigma=1, shape=(2 * n_dim, 1))
for ev in self.events:
ind = ev["mask"].values
obs = np.array(ev["index_among"])
expressions = tt.concatenate([x_t[ind, :], x_f[ind, :]],
axis=1)
hazard = tt.exp(tt.dot(expressions, b)).T
evp = pm.Categorical("event_{}".format(ev["sample"]),
hazard,
observed=obs)
elif self.hazard_model == "mk":
# This in not implemented and aims to model hazard with a gaussian mixture
b = pm.Normal("kernel_weights", mu=0, sigma=1, shape=(10, ))
pass
x = pm.Deterministic("x", mixSep(x_f, x_t, alpha, dev_f, dev_t))
if self.use_multinomial:
obs = pm.Multinomial("obs",
n=multiNn,
p=x,
observed=mCounts.T,
dtype="int64")
else:
dist = pm.Dirichlet.dist(mCounts.T + 1)
pot = pm.Potential("obs", dist.logp(x))
return model
K = len(cpf) # max breakpoints
P = 1 #len(cpf)
with pm.Model() as model: # The DP priors to obtain w, the cluster weights
alpha = pm.Gamma('alpha', 1.0, 1.0, shape=1)
beta = pm.Beta('beta', 1, alpha, shape=K)
w = pm.Deterministic('w', stick_breaking(beta))
# psi = pm.Uniform('psi', shape=(P, 1))
# prob = pm.Uniform('prob', shape=(P, 1))
# zb = pm.ZeroInflatedBinomial('zb', psi=psi, n=P, p=prob, shape=(P, K))
# obs = pm.Mixture('obs', w, zb, shape=(P, 1), observed=cpf['w_trend'][:, None])
# Prior on Bernoulli parameters, use Jeffrey's conjugate-prior
# theta = pm.Beta('theta', 0.5, 0.5, shape=(P, K))
theta = pm.Beta('theta', alpha=10.0, beta=0.5, shape=(P, K))
obs = pm.Mixture('obs', w, pm.Bernoulli.dist(theta, shape=(P, K)), shape=(P, 1), observed=cpf['w_trend'][:, None])
step_method = pm.NUTS(target_accept=0.90, max_treedepth=15)
cpt_trace = pm.sample(1000, chains=None, step=step_method, tune=1000)
cpt_smry = pm.summary(cpt_trace)
pm.traceplot(cpt_trace)
spp = pm.sample_posterior_predictive(cpt_trace, samples=1000, progressbar=False, var_names=['w', 'theta', 'alpha']) #, 'alpha', 'obs'])
# spp = pm.sample_posterior_predictive(cpt_trace, samples=1000, progressbar=False, var_names=['w', 'zb', 'prob', 'psi'])
K = 30
P = len(cpf) #
with pm.Model() as model:
# The DP priors to obtain w, the cluster weights
alpha = pm.Gamma('alpha', 1., 1.)
beta = pm.Beta('beta', 1, alpha, shape=K)
w = pm.Deterministic('w', stick_breaking(beta))
def __init__(self,
dimension,
mu_data,
tau_data,
prior="Gaussian",
parameters={
"location": None,
"scale": None,
"corr": False
},
hyper_alpha=None,
hyper_beta=None,
hyper_gamma=None,
hyper_delta=None,
transformation=None,
parametrization="non-central",
name='',
model=None):
assert isinstance(dimension, int), "dimension must be integer!"
assert dimension in [3, 5, 6], "Not a valid dimension!"
D = dimension
# 2) call super's init first, passing model and name
# to it name will be prefix for all variables here if
# no name specified for model there will be no prefix
super().__init__(str(D) + "D", model)
# now you are in the context of instance,
# `modelcontext` will return self you can define
# variables in several ways note, that all variables
# will get model's name prefix
#------------------- Data ------------------------------------------------------
N = int(len(mu_data) / D)
if N == 0:
sys.exit(
"Data has length zero!. You must provide at least one data point"
)
#-------------------------------------------------------------------------------
#============= Transformations ====================================
if transformation is "mas":
Transformation = Iden
elif transformation is "pc":
if D is 3:
Transformation = cartesianToSpherical
elif D is 6:
Transformation = phaseSpaceToAstrometry_and_RV
elif D is 5:
Transformation = phaseSpaceToAstrometry
D = 6
else:
sys.exit("Transformation is not accepted")
#==================================================================
#================ Hyper-parameters =====================================
if hyper_delta is None:
shape = 1
else:
shape = len(hyper_delta)
#--------- Location ----------------------------------
if parameters["location"] is None:
location = [
pm.Normal("loc_{0}".format(i),
mu=hyper_alpha[i][0],
sigma=hyper_alpha[i][1],
shape=shape) for i in range(D)
]
#--------- Join variables --------------
mu = pm.math.stack(location, axis=1)
else:
mu = parameters["location"]
#------------------------------------------------------
#------------- Scale --------------------------
if parameters["scale"] is None:
scale = [
pm.Gamma("scl_{0}".format(i),
alpha=2.0,
beta=2.0 / hyper_beta[i][0],
shape=shape) for i in range(D)
]
else:
scale = parameters["scale"]
#--------------------------------------------------
#----------------------- Correlation -----------------------------------------
if parameters["corr"]:
pm.LKJCorr('chol_corr', eta=hyper_gamma, n=D)
C = tt.fill_diagonal(
self.chol_corr[np.zeros((D, D), dtype=np.int64)], 1.)
# print_ = tt.printing.Print('C')(C)
else:
C = np.eye(D)
#-----------------------------------------------------------------------------
#-------------------- Covariance -------------------------
sigma_diag = pm.math.stack(scale, axis=1)
cov = theano.shared(np.zeros((shape, D, D)))
for i in range(shape):
sigma = tt.nlinalg.diag(sigma_diag[i])
covi = tt.nlinalg.matrix_dot(sigma, C, sigma)
cov = tt.set_subtensor(cov[i], covi)
#---------------------------------------------------------
#========================================================================
#===================== True values ============================================
if prior is "Gaussian":
pm.MvNormal("source", mu=mu, cov=cov[0], shape=(N, D))
elif prior is "GMM":
pm.Dirichlet("weights", a=hyper_delta, shape=shape)
comps = [
pm.MvNormal.dist(mu=mu[i], cov=cov[i]) for i in range(shape)
]
pm.Mixture("source",
w=self.weights,
comp_dists=comps,
shape=(N, D))
else:
sys.exit("The specified prior is not supported")
#=================================================================================
#----------------------- Transformation---------------------------------------
transformed = Transformation(self.source)
#-----------------------------------------------------------------------------
#------------ Flatten --------------------------------------------------------
true = pm.math.flatten(transformed)
#----------------------------------------------------------------------------
#----------------------- Likelihood ----------------------------------------
pm.MvNormal('obs', mu=true, tau=tau_data, observed=mu_data)
#------------------------------------------------------------------------------
