def lpd(count_data, R):
""" Compute lpd values of the 2 models, keep its difference, its standard deviation and the location of the change point found. """
N = len(count_data) #number of points
prs = max(count_data) + 10 # prior took high
nc = 6 # number of processor put high
#compute lpd value of the no change model
lpd_poisson = np.zeros(N) # list of lpd values of points
model_poisson_loo = stan_utility.compile_model('STAN/poisson_loo.stan')
for n in range(N): #iterate
d_loo = count_data[n] #point removed
d = np.array([count_data[i] for i in range(N)
if i != n]) #rest of data
fit_data = {"N": N, "d": d, "prs": prs, "d_loo": d_loo, "n_loo": n}
fit_nocp_loo = model_poisson_loo.sampling(data=fit_data,
iter=R,
chains=nc,
seed=4838282,
refresh=0) #4000 fits
lpd_poisson[n] = logsumexp(fit_nocp_loo["log_lik_d_loo"]) - np.log(
len(fit_nocp_loo["log_lik_d_loo"]))
loonochange = np.sum(lpd_poisson) # total lpd value of the model
# compute lpd value of the change point model
lpd_poisson_cp = np.zeros(N) # list of lpd values of points
model_poisson_loo_cp = stan_utility.compile_model(
'STAN/poisson_cp_loo.stan')
for n in range(N): #iterate
d_loo = count_data[n] #point removed
d = np.array([count_data[i] for i in range(N)
if i != n]) #rest of data
fit_data = {
"N": N,
"d": d,
"pes": prs,
"pls": prs,
"d_loo": d_loo,
"n_loo": n
}
fit_cp_loo = model_poisson_loo_cp.sampling(data=fit_data,
iter=R,
chains=nc,
seed=4838282,
refresh=0)
lpd_poisson_cp[n] = logsumexp(fit_cp_loo["log_lik_d_loo"]) - np.log(
len(fit_cp_loo["log_lik_d_loo"]))
loochange = np.sum(lpd_poisson_cp) # total lpd value of the model
#compute standard deviation of the difference of lpd values
diff = lpd_poisson_cp - lpd_poisson
sigma = np.sqrt(N * st.pvariance(diff))
#look for change point location
cpdistrib = cpsearch(count_data, R)
cp = np.argmax(cpdistrib)
return (
loochange - loonochange, sigma, cp
) #lpd value difference, its standard deviation, and change point location
def __init__(self,
dgp_model_name,
fit_model_name,
sampler_args,
stats=[],
seed=SEED):
self.fit_model_name = fit_model_name
self.fit_model = stan_utility.compile_model(fit_model_name)
self.dgp_model_name = dgp_model_name
self.dgp_model = stan_utility.compile_model(dgp_model_name)
self.sampler_args = sampler_args
self.stats = self.default_stats + stats
self.seed = seed
def __init__(self,
X: np.ndarray,
y: List[Tuple[int, float]],
yc: List[List[Tuple[int, int]]],
kernel: GPy.kern.Kern,
likelihood: Gaussian,
posterior_samples: int = 45,
get_logger: Callable = None):
super(MCMCComparisonGP, self).__init__(name="MCMC")
self.N, self.D = X.shape[0], X.shape[1]
self.output_dim = 1 ## hard coded
self.posterior_samples = posterior_samples
self.X = X
self.y = y
self.yc = yc
self.noise_std = np.sqrt(likelihood.variance[0])
self.sigma2s = (likelihood.variance[0]) * np.ones(
(X.shape[0], 1), dtype=int)
self.variance = kernel.variance[0]
self.lengthscale = np.array([kernel.lengthscale[:]]).flatten()
self.kern = kernel
self.posterior = None
if not os.path.exists(stan_utility.file_utils.get_path_of_cache()):
os.makedirs(stan_utility.file_utils.get_path_of_cache())
self.model = stan_utility.compile_model(os.path.join(
os.path.dirname(__file__), "inferences/sexpgp_comparison.stan"),
model_name='comparison_model')
self.get_logger = get_logger
self.parameters_changed()
def test_compile_file():
import stan_utility.cache
with tempfile.TemporaryDirectory() as cachedir:
print("using cachedir:", cachedir)
stan_utility.cache.path = cachedir
stan_utility.cache.mem = joblib.Memory(cachedir, verbose=False)
import stan_utility
model = stan_utility.compile_model(os.path.join(os.path.dirname(__file__), 'test.stan'))
data = dict(
mean=1,
unused=np.random.normal(size=(4,42)),
)
stan_utility.sample_model(model, data, chains=2)
files = os.listdir(stan_utility.cache.get_path())
assert "joblib" in files
assert any(f for f in files if f.startswith("cached-") and f.endswith('.pkl')), files
assert len(files) > 1, files
stan_utility.cache.clear()
files = os.listdir(stan_utility.cache.get_path())
assert files == ["joblib"], files
def cpsearch(count_data, R):
""" Return the probability density function of the change point over the list of rates count_data"""
N = len(count_data) #number of points
prs = max(count_data) + 10 # prior took high
nc = 6 # number of processor put high
fit_data = {
"N": N,
"d": count_data,
"pes": prs,
"pls": prs
} # fit the data
model_cp = stan_utility.compile_model('STAN/poisson_cp_ppc.stan')
fit_cp = model_cp.sampling(
data=fit_data, iter=R, chains=nc, seed=4838282,
refresh=0) # fit the change point model to the data
#convert fitting result to PDF curve
bins = np.linspace(1, N, N + 1)
counts = [
np.histogram(x, bins=bins)[0] for x in fit_cp["cp"][np.newaxis, :]
]
probs = [10, 20, 30, 40, 50, 60, 70, 80, 90]
counts = [c / (R * 3) for c in counts]
creds = [
np.percentile([count[b] for count in counts], probs) for b in range(N)
]
idxs = [idx for idx in range(N)]
xs = [
bins[idx] + delta for idx in range(N)
for delta in [0, bins[1] - bins[0]]
]
pad_creds = [creds[idx] for idx in idxs]
proba = [c[4] for c in pad_creds]
return proba
def plot_nocp(count_data, R):
""" Fit the no change point model on the data and plot the result. """
N = len(count_data) #number of points
prs = max(count_data) + 10 # prior took high
nc = 6 # number of processor put high
#fitting
fit_data = {"N": N, "d": count_data, "prs": prs}
model_nocp = stan_utility.compile_model('STAN/poisson_ppc.stan')
# posterior predictive distribution
Xs = fit_nocp['d_ppc']
cumsums = np.array([np.cumsum(x) for x in Xs])
probs = [10, 20, 30, 40, 50, 60, 70, 80, 90]
creds = [np.percentile(xt, probs) for xt in cumsums.T]
idxs = [idx for idx in range(Xs.shape[1]) for r in range(2)]
xs = [
idx + delta for idx in range(1, Xs.shape[1] + 1)
for delta in [-0.5, 0.5]
]
pad_creds = [creds[idx] for idx in idxs]
#plotting
plt.figure()
plt.fill_between(xs, [c[0] for c in pad_creds], [c[8] for c in pad_creds],
facecolor=light,
color=light,
label='80% predictive distribution')
plt.fill_between(xs, [c[0] for c in pad_creds], [c[7] for c in pad_creds],
facecolor=light_highlight,
color=light_highlight,
label='60%')
plt.fill_between(xs, [c[2] for c in pad_creds], [c[6] for c in pad_creds],
facecolor=mid,
color=mid,
label='40%')
plt.fill_between(xs, [c[3] for c in pad_creds], [c[5] for c in pad_creds],
facecolor=mid_highlight,
color=mid_highlight,
label='20%')
plt.plot(xs, [c[4] for c in pad_creds],
color=dark,
label='model',
linewidth=1)
plt.legend(bbox_to_anchor=(0.025, 1.06),
loc=2,
borderaxespad=0.,
fontsize=12)
plt.gca().set_xlim([0, Xs.shape[1]])
plt.gca().set_xlabel("Data point", size=15)
plt.xticks(fontsize=15)
plt.gca().set_ylim([0, max([c[8] for c in creds])])
plt.gca().set_ylabel("Cumulative number of events",
size=15,
color='crimson')
plt.yticks(fontsize=12)
plt.show()
return
def __init__(self, stan_sim_file, include_paths):
"""
Handles posterior predictive checks.
:param stan_sim_file: the stan file to use to run the simulation
"""
# compile the stan model
self.simulation = stan_utility.compile_model(
filename=stan_sim_file,
model_name='ppc_sim',
include_paths=include_paths)
self.arrival_direction_preds = []
self.Edet_preds = []
self.Nex_preds = []
self.labels_preds = []
def run_stan_sim(N, Eth_sim, alpha, D, Eth, f_E, sim_filename):
"""
Run the Stan simulation for N events above Eth_sim from distance D
and return the fraction above Eth.
:param N: Number of UHECRs to simulate.
:param Eth_sim: The minimum energy of UHECR generated in the simulation.
:param alpha: The spectral index of the sourc UHECR (power law spectrum).
:param D: The distance at which a shell of sources is to be placed.
:param Eth: The threshold energy of a UHECR sample.
:param f_E: Fractional energy uncertainty
:param sim_filename: The filename of the Stan simulation code.
:return: The detection probability for Edet > Eth and Earr > Eth.
"""
# Run the simulation.
sim_input = {
'N': N,
'alpha': alpha,
'Eth_sim': Eth_sim,
'D': D,
'f_E': f_E
}
sim = stan_utility.compile_model(filename=sim_filename,
model_name='uhecr_E_loss',
include_paths=stan_path)
sim_output = sim.sampling(data=sim_input,
iter=1,
chains=1,
algorithm="Fixed_param")
# Extract the output.
E = sim_output.extract(['E'])['E'][0]
Earr = sim_output.extract(['Earr'])['Earr'][0]
Edet = sim_output.extract(['Edet'])['Edet'][0]
# Count number above threshold
N_arr_gt_Eth = np.shape(np.where(Earr > Eth))[1]
N_det_gt_Eth = np.shape(np.where(Edet > Eth))[1]
return (N_arr_gt_Eth / N), (N_det_gt_Eth / N)
f.create_dataset('Eth', data=Eth)
f.create_dataset('Eth_sim', data=Eth_sim)
f.create_dataset('alpha', data=alpha)
f.create_dataset('Ncr', data=Ncr)
f.create_dataset('Ntrials', data=Ntrials)
f.create_dataset('Ds', data=Ds)
f.create_dataset('f_E', data=f_E)
# Initialise
f.create_dataset('Parr', (len(Ds), ), 'f')
f.create_dataset('Pdet', (len(Ds), ), 'f')
f.create_dataset('D', (len(Ds), ), 'f')
# Compile the Stan model
sim = stan_utility.compile_model(filename=sim_filename,
model_name='uhecr_E_loss',
include_paths=stan_path)
done = False
# Start loop over Ds
for i, d in enumerate(Ds):
if COMM.rank == 0:
#print('D:', d)
start_time = time.time()
Eth = Eth
Ncr = Ncr
def plot_cp(count_data, R):
""" Fit the change point model to the data and plot the result. """
N = len(count_data) #number of points
prs = max(count_data) + 10 # prior took high
nc = 6 # number of processor put high
#fitting
fit_data = {"N": N, "d": count_data, "pes": prs, "pls": prs}
model_cp = stan_utility.compile_model('STAN/poisson_cp_ppc.stan')
fit_cp = model_cp.sampling(data=fit_data,
iter=R,
chains=nc,
seed=4838282,
refresh=0)
#probability density function
bins = np.linspace(1, N, N + 1)
counts = [
np.histogram(x, bins=bins)[0] for x in fit_cp["cp"][np.newaxis, :]
]
probs = [10, 20, 30, 40, 50, 60, 70, 80, 90]
counts = [c / (R * 3) for c in counts]
creds = [
np.percentile([count[b] for count in counts], probs) for b in range(N)
]
idxs = [idx for idx in range(N)]
xs = [
bins[idx] + delta for idx in range(nbins)
for delta in [0, bins[1] - bins[0]]
]
pad_creds = [creds[idx] for idx in idxs]
proba = [c[4] for c in pad_creds]
# posterior predictive distribution
Xs = fit_cp['d_ppc']
cumsums = np.array([np.cumsum(x) for x in Xs])
probs = [10, 20, 30, 40, 50, 60, 70, 80, 90]
creds = [np.percentile(xt, probs) for xt in cumsums.T]
idxs = [idx for idx in range(Xs.shape[1]) for r in range(2)]
xs = [
idx + delta for idx in range(1, Xs.shape[1] + 1)
for delta in [-0.5, 0.5]
]
pad_creds = [creds[idx] for idx in idxs]
#plotting
plotline = np.cumsum(count_data)
fig, ax1 = plt.subplots()
ax1.fill_between(xs, [c[0] for c in pad_creds], [c[8] for c in pad_creds],
facecolor=light,
color=light,
label='80% predictive distribution')
ax1.fill_between(xs, [c[0] for c in pad_creds], [c[7] for c in pad_creds],
facecolor=light_highlight,
color=light_highlight,
label='60%')
ax1.fill_between(xs, [c[2] for c in pad_creds], [c[6] for c in pad_creds],
facecolor=mid,
color=mid,
label='40%')
ax1.fill_between(xs, [c[3] for c in pad_creds], [c[5] for c in pad_creds],
facecolor=mid_highlight,
color=mid_highlight,
label='20%')
ax1.plot(xs, [c[4] for c in pad_creds], color=dark, label='model', lw=1)
ax1.plot(range(1, len(plotline) + 1), plotline, c='k', lw=2, label='data')
ax1.set_xlabel('Data point', size=15)
ax1.set_ylabel('Cumulative nomber', color='crimson', size=15)
for tl in ax1.get_yticklabels():
tl.set_color('crimson')
ax2 = ax1.twinx()
ax2.plot(proba, color='navy', linewidth=1)
ax2.set_ylim([0, 0.7])
ax2.set_ylabel('Probability Density Function of the change point',
color="navy",
size=12)
for tl in ax2.get_yticklabels():
tl.set_color("navy")
ax1.legend(bbox_to_anchor=(0.025, 1.06),
loc=2,
borderaxespad=0.,
fontsize=12)
plt.xticks(fontsize=15)
plt.show()
return
mid_highlight="#A25050"
dark="#8F2727"
dark_highlight="#7C0000"
green="#00FF00"
############################################################
#
# One-dimensional
#
############################################################
############################################################
# Create data
############################################################
model = stan_utility.compile_model('generate_data.stan')
fit = model.sampling(seed=194838, algorithm='Fixed_param', iter=1, chains=1)
data = dict(N = fit.extract()['N'].astype(numpy.int64),
x_obs = fit.extract()['x_obs'][0,:])
pystan.stan_rdump(data, 'selection.data.R')
############################################################
# Fit model
############################################################
data = pystan.read_rdump('selection.data.R')
model = stan_utility.compile_model('selection.stan')
fit = model.sampling(data=data, chains=4, seed=4938483,
def do_run(xpred, num_datapoints, num_feedbacks, acquisition, seed,
save_folder, stan_folder):
filename = save_folder + str(xpred).replace('.', '_') + '-' + str(seed)
tr_data, beta_true = generate_data(N=num_datapoints, seed=seed)
print('xpred: ' + str(xpred))
# fit model on training data
dat = {
'n': num_datapoints,
'npred': 2,
'x': tr_data[0],
'a': tr_data[1],
'y': tr_data[2],
'xpred': np.array([xpred, xpred]),
'apred': np.array([0, 1])
}
# Compute imbalance
imbalance = [compute_imbalance(dat['x'], dat['a'])]
# Fit model
model = stan_utility.compile_model(
'logit2.stan',
model_name='logit-' + str(xpred).replace('.', '_') + '-' + str(seed),
model_path=stan_folder)
fit = model.sampling(data=dat, seed=194838, chains=4, iter=2000)
samples = fit.extract(permuted=True)
# Compute the estimated Type S error rate
typeSerror = [error_rate(samples)]
# Compute decision and regret in current model
a0 = decide(samples)
decisions = [a0]
regrets = [regret(beta_true, xpred, a0)]
x_s, a_s, y_s = [], [], []
for it in range(num_feedbacks):
print('it: ' + str(it))
# Elicit one feedback with different criterion
x_star, a_star = select_query(model, samples, dat, acquisition)
# Acquire feedback from oracle (we assume true model)
y_star = predict_with_model(beta_true, x_star, a_star)
# Fit new model, compute decisions and regret
x_s += [x_star]
a_s += [a_star]
y_s += [y_star]
dat = append_dat_stan(dat, x_star, a_star, y_star)
# Compute imbalance
imbalance += [compute_imbalance(dat['x'], dat['a'])]
# Re-fit the model
fit = model.sampling(data=dat, seed=194838, chains=4, iter=2000)
samples = fit.extract(permuted=True)
typeSerror += [error_rate(samples)]
a1 = decide(samples)
decisions += [a1]
regrets += [regret(beta_true, xpred, a1)]
print(filename)
dat_save = {
'regrets': regrets,
'x_s': x_s,
'a_s': a_s,
'y_s': y_s,
'imbalances': imbalance,
'typeSerrors': typeSerror,
'decisions': decisions
}
pickle.dump(dat_save, open(filename + ".p", "wb"))
for (j in 1:J)
z_u[j] ~ normal(p_r[1],p_r[2]);
//likelihood
for (n in 1:N)
mu[n] = alpha + X_beta[n] * beta + Z_u[n] * u[subj[n]];
y ~ normal(mu, sigma);
}
generated quantities {
matrix[n_u,n_u] Cor_u;
vector[N] log_lik;
vector[N] y_hat; // predicted y
real raw_intercept; //raw intercept if log values
vector[P-1] raw_beta; //raw effect size if log values
Cor_u = tcrossprod(L_u); //Correlations between random effects by subj
if (logT == 1) {
raw_intercept = exp(alpha);
raw_beta = exp(alpha + beta) - raw_intercept;
}
for (n in 1:N){
log_lik[n] = normal_lpdf(y[n] | alpha + X_beta[n] * beta + Z_u[n] * u[subj[n]], sigma);
y_hat[n] = normal_rng(alpha + X_beta[n] * beta + Z_u[n] * u[subj[n]], sigma);
}
}
"""
f = open("LME.stan", "w+")
f.write(LME)
f.close()
LME = stan_utility.compile_model('LME.stan', model_name="LME")
import stan_utility
import pystan
import numpy as np
model = stan_utility.compile_model('gbm_sum.stan', model_name='test_gbm2')
data = pystan.read_rdump('alpha_data.R')
N_gen_spectra = 100
model_energy = np.logspace(0,5,N_gen_spectra)
data['N_gen_spectra'] = N_gen_spectra
data['model_energy'] = model_energy
warmup = 1000
iter = 100
total = warmup + iter
chains = 8
fit = model.sampling(
data=data,
iter=total,
warmup=warmup,
chains=chains,
n_jobs=chains,
control=dict(max_treedepth=13,
# adapt_delta=0.9
),
seed=1234)
stan_utility.stanfit_to_hdf5(fit, '/data/jburgess/stan_fits/gbm_stan_fit_small.h5')
def run_linear_model(model_src, plot_title, save_loc):
"""
Run linear model.
:param model_src: source of stan model.
:param plot_title: title of output plot.
:param save_loc: location of output plot.
:return:
"""
n = data.shape[0]
m = 5
x = data[['BTC price']].values.flatten()[0:n]
y1 = data[['DASH price']].values.flatten()[0:n]
y2 = data[['LTC price']].values.flatten()[0:n]
y3 = data[['ETH price']].values.flatten()[0:n]
y4 = data[['ETC price']].values.flatten()[0:n]
p = np.linspace(data[['BTC price']].min(), data[['BTC price']].max(), m)
print(p)
model = stan_utility.compile_model(model_src)
data1 = dict(N=n, M=m, x=x, y=y1, xpreds=p)
fit1 = model.sampling(data=data1, seed=74749)
samples1 = fit1.extract(permuted=True)
print_loo_and_ks(samples1)
data2 = dict(N=n, M=m, x=x, y=y2, xpreds=p)
fit2 = model.sampling(data=data2, seed=74749)
samples2 = fit2.extract(permuted=True)
print_loo_and_ks(samples2)
data3 = dict(N=n, M=m, x=x, y=y3, xpreds=p)
fit3 = model.sampling(data=data3, seed=74749)
samples3 = fit3.extract(permuted=True)
print_loo_and_ks(samples3)
data4 = dict(N=n, M=m, x=x, y=y4, xpreds=p)
fit4 = model.sampling(data=data4, seed=74749)
samples4 = fit4.extract(permuted=True)
print_loo_and_ks(samples4)
f, axes = plt.subplots(2, 2, figsize=(14, 10))
preds = samples1['ypreds'].T
ax = axes[0, 0]
ax.scatter(data['BTC price'], data['DASH price'], alpha=0.5)
ax.set_ylabel('DASH price')
ax.set_xlabel('BTC price')
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
for i in range(m):
ax.scatter([p[i]] * len(preds[i]), preds[i], alpha=0.1, c='g')
ax.scatter(p[i], np.mean(preds[i]), c='r')
preds = samples2['ypreds'].T
ax = axes[0, 1]
ax.scatter(data['BTC price'], data['LTC price'], alpha=0.5)
ax.set_ylabel('LTC price')
ax.set_xlabel('BTC price')
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
for i in range(m):
ax.scatter([p[i]] * len(preds[i]), preds[i], alpha=0.1, c='g')
ax.scatter(p[i], np.mean(preds[i]), c='r')
preds = samples3['ypreds'].T
ax = axes[1, 0]
ax.scatter(data['BTC price'], data['ETH price'], alpha=0.5)
ax.set_ylabel('ETH price')
ax.set_xlabel('BTC price')
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
for i in range(m):
ax.scatter([p[i]] * len(preds[i]), preds[i], alpha=0.1, c='g')
ax.scatter(p[i], np.mean(preds[i]), c='r')
preds = samples4['ypreds'].T
ax = axes[1, 1]
ax.scatter(data['BTC price'], data['ETC price'], alpha=0.5)
ax.set_ylabel('ETC price')
ax.set_xlabel('BTC price')
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
for i in range(m):
ax.scatter([p[i]] * len(preds[i]), preds[i], alpha=0.1, c='g')
ax.scatter(p[i], np.mean(preds[i]), c='r')
red_patch = mpatches.Patch(color='red', )
green_patch = mpatches.Patch(color='green')
f.legend([red_patch, green_patch], ['mean', 'spread'],
loc='upper right',
ncol=1)
f.suptitle(plot_title, fontsize=14)
plt.savefig(save_loc)
plt.show()
data['zcmb'] = np.array(jla_data_set['zcmb'])
data['c_obs'] = np.array(jla_data_set['color'])
data['c_sigma'] = np.array(jla_data_set['dcolor'])
data['x1_obs'] = np.array(jla_data_set['x1'])
data['x1_sigma'] = np.array(jla_data_set['dx1'])
data['m_obs'] = np.array(jla_data_set['mb'])
data['m_sigma'] = np.array(jla_data_set['dmb'])
data['N_model'] = n_model
data['z_model'] = z_model
n_warmup = 1000
n_samp = 250
iter = n_warmup + n_samp
n_chain = 4
model = stan_utility.compile_model('supernove_model.stan', 'sn_cosmo')
fit = model.sampling(data=data,
iter=iter,
warmup=n_warmup,
chains=n_chain,
n_jobs=n_chain,
thin=1,
seed=1234,
control=dict(max_treedepth=13, adapt_delta=0.95))
stan_utility.stanfit_to_hdf5(fit, 'sncosmo_fit.h5')
## generate fake data according to the data-generating process described by
## your model.
## 2. Follow the rest of this workflow with your fake data!
#############
# To use Stan to generate fake data, we use the `generated quantities` block
# and the 'Fixed_param' algorithm. The following snippet will generate
# 200 fake data points.
# gen.model = stan_model("gen.stan")
# gen.data = sampling(data=d, algorithm='Fixed_param', warmup=0, iter=200)
# gendf = as.data.frame(gen.data)
# dataset.1 = gendf[1,]
#############
## Fit the model
#############
model = util.compile_model("../pooled.stan")
fit = model.sampling(dict(log_radon=df.log_radon,
basement = df.basement,
N=df.shape[0]))
# #############
# ## Check diagnostics
# #############
util.check_all_diagnostics(fit)
# #############
# ## Check & graph fit
# #############
print(fit)
sample = fit.extract()
# # This line just plots our data by basement indicator
data['x1_obs'] = np.array(jla_data_set['x1'])
data['x1_sigma'] = np.array(jla_data_set['dx1'])
data['m_obs'] = np.array(jla_data_set['mb'])
data['m_sigma'] = np.array(jla_data_set['dmb'])
data['N_model'] = n_model
data['z_model'] = z_model
n_warmup=1000
n_samp = 250
iter = n_warmup + n_samp
n_chain = 4
model = stan_utility.compile_model('supernovae_simple.stan','sn_cosmo_simple');
fit = model.sampling(
data=data,
iter=iter,
warmup=n_warmup,
chains=n_chain,
n_jobs=n_chain,
thin=1,
seed=1234,
control=dict(max_treedepth=13, adapt_delta=0.95))
stan_utility.stanfit_to_hdf5(fit, 'sncosmo_simple_fit.h5')
data['h0'] = 70.
data['zcmb'] = np.array(jla_data_set['zcmb'])
data['c_obs'] = np.array(jla_data_set['color'])
data['c_sigma'] = np.array(jla_data_set['dcolor'])
data['x1_obs'] = np.array(jla_data_set['x1'])
data['x1_sigma'] = np.array(jla_data_set['dx1'])
data['m_obs'] = np.array(jla_data_set['mb'])
data['m_sigma'] = np.array(jla_data_set['dmb'])
n_warmup = 1000
n_samp = 250
iter = n_warmup + n_samp
n_chain = 4
model = stan_utility.compile_model('supernove_model_bias.stan',
'sn_cosmo_bias')
fit = model.sampling(data=data,
iter=iter,
warmup=n_warmup,
chains=n_chain,
n_jobs=n_chain,
thin=1,
seed=1234,
control=dict(max_treedepth=13, adapt_delta=0.85))
stan_utility.stanfit_to_hdf5(fit, 'sncosmo_bias_fit.h5')
for m in range(M):
running_samples = x0[0:iters[m]]
mcmc_stats = compute_mcmc_stats(running_samples)
x1_mean[m] = mcmc_stats[0]
x1_se[m] = mcmc_stats[1]
return iters, x1_mean, x1_se
############################################################
# Normal Model
############################################################
# Compile Stan program and fit with dynamic Hamiltonian Monte Carlo
model = stan_utility.compile_model('normal.stan')
fit = model.sampling(seed=4838282)
# Check diagnostics
stan_utility.check_all_diagnostics(fit)
# Check MCMC estimators
print(fit)
############################################################
# Student-t Model
############################################################
model = stan_utility.compile_model('student_t.stan')
# 100 degrees of freedom
facecolor=mid_highlight,
color=mid_highlight)
plot.plot(xs, [c[4] for c in pad_creds], color=dark)
plot.gca().set_xlim([min(bins), max(bins)])
plot.gca().set_xlabel("y")
plot.gca().set_ylim([0, max([c[8] for c in creds])])
plot.gca().set_ylabel("Prior Predictive Distribution")
plot.axvline(x=25, linewidth=2.5, color="white")
plot.axvline(x=25, linewidth=2, color="black")
plot.show()
float(len([y for y in simu_ys.flatten() if y > 25])) / len(simu_ys.flatten())
simus = zip(simu_lambdas, simu_ys)
fit_model = stan_utility.compile_model('fit_data.stan')
def analyze_simu(simu):
simu_l = simu[0]
simu_y = simu[1]
# Fit the simulated observation
input_data = dict(N=N, y=simu_y)
fit = fit_model.sampling(data=input_data, seed=4938483, n_jobs=1)
# Compute diagnostics
warning_code = stan_utility.check_all_diagnostics(fit, quiet=True)
# Compute rank of prior draw with respect to thinned posterior draws
