def build_cmdstan_model(target_dir):
"""
Rebuild cmdstan in the build environment, then use this installation to compile the stan model.
The stan model is copied to {target_dir}/prophet_model.bin
The cmdstan files required to run cmdstanpy commands are copied to {target_dir}/cmdstan-{version}.
Parameters
----------
target_dir: Directory to copy the compiled model executable and core cmdstan files to.
"""
import cmdstanpy
cmdstan_cache = get_cmdstan_cache()
download_cmdstan(cmdstan_cache)
cmdstan_dir = os.path.join(target_dir, f"cmdstan-{CMDSTAN_VERSION}")
if os.path.isdir(cmdstan_dir):
rmtree(cmdstan_dir)
copytree(cmdstan_cache, cmdstan_dir)
with cmdstanpy.utils.pushd(cmdstan_dir):
clean_all_cmdstan()
build_cmdstan()
cmdstanpy.set_cmdstan_path(cmdstan_dir)
model_name = "prophet.stan"
target_name = "prophet_model.bin"
sm = cmdstanpy.CmdStanModel(stan_file=os.path.join(MODEL_DIR, model_name))
copy(sm.exe_file, os.path.join(target_dir, target_name))
# Clean up
for f in Path(MODEL_DIR).iterdir():
if f.is_file() and f.name != model_name:
os.remove(f)
prune_cmdstan(cmdstan_dir)
def variational(mi: MaudInput, output_dir: str) -> CmdStanVB:
"""Do variational inference for the posterior defined by mi.
:param mi: a MaudInput object
:param output_dir: a string specifying where to save the output.
"""
mi_options = (
{}
if mi.config.variational_options is None
else mi.config.variational_options
)
model = cmdstanpy.CmdStanModel(
stan_file=os.path.join(HERE, STAN_PROGRAM_RELATIVE_PATH),
cpp_options=mi.config.cpp_options,
stanc_options=mi.config.stanc_options,
)
set_up_output_dir(output_dir, mi)
return model.variational(
data=os.path.join(output_dir, "input_data_train.json"),
inits=os.path.join(output_dir, "inits.json"),
**{
**DEFAULT_VARIATIONAL_CONFIG,
**mi_options,
**{"output_dir": output_dir},
},
)
def fit_original_model():
# There are a few places where I fit this model.
# Easiest if I just make it a function. Less copy pasta
concentration_data = pd.read_csv("data/generated_data/experiment.csv")
subject_data = concentration_data.drop_duplicates(['subjectids'])
model_data = dict(sex=subject_data.sex.tolist(),
weight=subject_data.weight.tolist(),
age=subject_data.age.tolist(),
creatinine=subject_data.creatinine.tolist(),
n_subjectids=subject_data.shape[0],
D=subject_data.D.tolist(),
subjectids=concentration_data.subjectids.tolist(),
time=concentration_data.time.tolist(),
yobs=concentration_data.yobs.tolist(),
n=concentration_data.shape[0])
model = cmdstanpy.CmdStanModel(
stan_file='experiment_models/original_model.stan')
fit = model.sample(model_data,
chains=12,
parallel_chains=4,
seed=19920908,
show_progress=True)
return fit, model_data
def setup_model(*, cmdstan_dir, model_dir, name, model, data):
"""Compile Stan model."""
cmdstanpy.set_cmdstan_path(cmdstan_dir)
model = model.replace("<-", "=")
with tempfile.NamedTemporaryFile("w",
prefix=f"{name}_",
suffix=".stan",
dir=model_dir,
delete=False) as f:
print(model, file=f)
model_file = f.name
with tempfile.NamedTemporaryFile("w",
prefix=f"{name}_",
suffix=".json",
dir=model_dir,
delete=False) as f:
json.dump(data, f, indent=2, sort_keys=True)
data_file = f.name
model_object = cmdstanpy.CmdStanModel(stan_file=model_file)
exe_file = model_object.exe_file
return model_file, data_file, exe_file
def test_prior_predictive():
fit, model_data = fit_original_model()
t_unique = np.unique(model_data['time'])
c_check = fit.stan_variable('c_check')
posterior_from_original = np.quantile(c_check, [0.025, 0.5, 0.975], axis = 0)
# Fit the prior predictive
with open('data/param_summary.pkl','rb') as file:
params = pickle.load(file)
#The params should be 1 on the z-standardized scale.
params['sex'] = 1
params['weight'] = params['weight_mean'] + params['weight_sd']
params['creatinine'] = params['creatinine_mean'] + params['weight_sd']
params['age'] = params['age_mean'] + params['age_sd']
params['nt'] = 8
params['prediction_times'] = t_unique.tolist()
params['n_doses'] = 1
params['dose_times'] = [0]
params['doses'] = [1.0]
prior_model = cmdstanpy.CmdStanModel(stan_file = 'experiment_models/prior_predictive.stan')
prior_predictive = prior_model.sample(params, fixed_param=True, chains=1, iter_sampling = 2000, seed = 19920908)
c_check_2 = prior_predictive.stan_variable('C')
posterior_from_summary= np.quantile(c_check_2, [0.025, 0.5, 0.975], axis = 0)
np.testing.assert_allclose(posterior_from_original, posterior_from_summary, atol = 0.01)
def load_model(self):
import cmdstanpy
model_file = pkg_resources.resource_filename(
'fbprophet',
'stan_model/prophet_model.bin',
)
return cmdstanpy.CmdStanModel(exe_file=model_file)
def _sample_given_config(mi: MaudInput, output_dir: str,
config: dict) -> cmdstanpy.CmdStanMCMC:
"""Call CmdStanModel.sample, having already specified all arguments.
:param mi: a MaudInput object
:param output_dir: a string specifying where to save the output.
:param config: a dictionary of keyword arguments to CmdStanModel.sample.
"""
input_filepath = os.path.join(output_dir, "input_data.json")
input_data = get_input_data(mi)
cmdstanpy.utils.jsondump(input_filepath, input_data)
stan_program_filepath = os.path.join(HERE, STAN_PROGRAM_RELATIVE_PATH)
include_path = os.path.join(HERE, INCLUDE_PATH)
cpp_options = {}
stanc_options = {"include_paths": [include_path]}
if config["threads_per_chain"] != 1:
cpp_options["STAN_THREADS"] = True
os.environ["STAN_NUM_THREADS"] = str(config["threads_per_chain"])
model = cmdstanpy.CmdStanModel(
stan_file=stan_program_filepath,
stanc_options=stanc_options,
cpp_options=cpp_options,
)
return model.sample(data=input_filepath, **config)
def load_model(self):
import cmdstanpy
self._add_tbb_to_path()
model_file = pkg_resources.resource_filename(
'prophet',
'stan_model/prophet_model.bin',
)
return cmdstanpy.CmdStanModel(exe_file=model_file)
def compile(file, log=None):
if log is None:
log = _log
_log.info('preparing Stan model %s', file)
mod = cmdstanpy.CmdStanModel(file.stem,
file,
logger=log,
cpp_options={'STAN_THREADS': 'yes'})
return mod
def build_model(target_dir, model_dir):
from shutil import copy
import cmdstanpy
model_name = 'prophet.stan'
target_name = 'prophet_model.bin'
sm = cmdstanpy.CmdStanModel(
stan_file=os.path.join(model_dir, model_name))
sm.compile()
copy(sm.exe_file, os.path.join(target_dir, target_name))
def sample(dir, model_file, data_file, exe_file, args=None):
"""Run sample."""
if args is None:
args = {}
model_object = cmdstanpy.CmdStanModel(
stan_file=model_file,
exe_file=exe_file,
)
fit = model_object.sample(data=data_file, **args)
fit.save_csvfiles(dir=dir)
return fit.runset.csv_files
def build_model(self):
"""
build the stan model
:returns:
:rtype:
"""
cpp_options = dict(STAN_THREADS=True)
self._model = cmdstanpy.CmdStanModel(stan_file=self._stan_file,
model_name=self._name,
cpp_options=cpp_options)
def test_model_ode(folder, csv_ixs, meaningful_ixs, expected_values):
"""Test that the function get_input_data behaves as expected."""
input_path = os.path.join(data_path, folder)
init_data = os.path.join(input_path, "inits.json")
input_data = os.path.join(input_path, "input_data_train.json")
SIM_CONFIG["inits"] = init_data
model = cmdstanpy.CmdStanModel(stan_file=model_path)
sim_values = (model.sample(data=input_data,
**SIM_CONFIG).draws_pd().loc[0,
csv_ixs].to_list())
for meaningful_ix, expected_value, sim_value in zip(
meaningful_ixs, expected_values, sim_values):
var = meaningful_ix.split("|")[0]
ix = " ".join(meaningful_ix.split("|")[1:])
msg = (f"\nExpected value of {var} {ix}: {expected_value}"
f"\nSimulated value:\n {sim_value}")
assert isclose(expected_value, sim_value), msg
def simulate(mi: MaudInput, output_dir: str, n: int) -> CmdStanMCMC:
"""Generate simulations from the prior mean.
:param mi: a MaudInput object
:param output_dir: a string specifying where to save the output.
"""
model = cmdstanpy.CmdStanModel(
stan_file=os.path.join(HERE, STAN_PROGRAM_RELATIVE_PATH),
cpp_options=mi.config.cpp_options,
stanc_options=mi.config.stanc_options,
)
set_up_output_dir(output_dir, mi)
return model.sample(
output_dir=output_dir,
iter_sampling=n,
data=os.path.join(output_dir, "input_data_train.json"),
inits=os.path.join(output_dir, "inits.json"),
**SIM_CONFIG,
)
def cached_stan_model(source):
"""Compiles and caches a Stan model.
Args:
source: Stan model source code.
Returns:
model: Compiled Stan model.
"""
filename = FLAGS.stan_model_filename_template.format(
hashlib.md5(source.encode('ascii')).hexdigest()) + '.stan'
# We rely on CmdStanPy's internal caching, based on mtimes of the source and
# binary files. CmdStanPy will not recompile the model if the binary is newer
# than the source file.
if not os.path.exists(filename):
with open(filename, 'w') as f:
f.write(source)
model = cmdstanpy.CmdStanModel(stan_file=filename)
model.compile()
return model
def sample(mi: MaudInput, output_dir: str) -> CmdStanMCMC:
"""Sample from the posterior defined by mi.
:param mi: a MaudInput object
:param output_dir: a string specifying where to save the output.
"""
model = cmdstanpy.CmdStanModel(
stan_file=os.path.join(HERE, STAN_PROGRAM_RELATIVE_PATH),
cpp_options=mi.config.cpp_options,
stanc_options=mi.config.stanc_options,
)
set_up_output_dir(output_dir, mi)
sample_args: dict = {
"data": os.path.join(output_dir, "input_data_train.json"),
"inits": os.path.join(output_dir, "inits.json"),
"output_dir": output_dir,
}
sample_args = {**sample_args, **DEFAULT_SAMPLE_CONFIG}
if mi.config.cmdstanpy_config is not None:
sample_args = {**sample_args, **mi.config.cmdstanpy_config}
return model.sample(**sample_args)
def get_stan_model(stan_model, mpi=False, threads=True):
assert (
stan_model in _available_models
), f"{stan_model} is not in {','.join(_available_models)}"
stan_file = pkg_resources.resource_filename(
"pyipn", os.path.join("stan_models", stan_model)
)
cpp_options = {}
if mpi:
cpp_options["STAN_MPI"] = True
if threads:
cpp_options["STAN_THREADS"] = True
model = cmdstanpy.CmdStanModel(stan_file=stan_file, cpp_options=cpp_options)
return model
def test_model_ode():
"""Test that the function get_input_data behaves as expected."""
input_path = os.path.join(data_path, "example_ode")
init_data = os.path.join(input_path, "inits.json")
input_data = os.path.join(input_path, "input_data.json")
SIM_CONFIG["inits"] = init_data
cpp_options = {}
model = cmdstanpy.CmdStanModel(
stan_file=model_path,
stanc_options=stanc_options,
cpp_options=cpp_options,
)
remap = {
"conc[1,1]": "A",
"conc[1,2]": "B",
"conc[1,3]": "C",
"conc[1,4]": "D",
"flux[1,1]": "r1",
"flux[1,4]": "r4",
}
true_values = {
"A": 5.0,
"B": 0.323117,
"C": 3.02187,
"D": 0.5,
"r1": 0.421816,
"r4": 2.11674,
}
sim_values = (
model.sample(data=input_data, **SIM_CONFIG)
.draws_pd()
.rename(columns=remap)
.T.loc[true_values.keys(), 0]
.to_dict()
)
msg = f"\nTrue values:\n {true_values}\nSimulated values:\n {sim_values}"
for true_value, sim_value in zip(true_values.values(), sim_values.values()):
assert isclose(true_value, sim_value), msg
def fit(
formula: str,
data: typing.Union[dict, pd.DataFrame],
priors: list = [],
family: str = "gaussian",
sample_prior: str = "no",
sample: bool = True,
name: str = None,
outdir: str = ".",
stan_exe_file: str = None,
**stan_args,
):
data = _convert_python_to_R(data)
# no executable passed -- compile model
if stan_exe_file is None:
formula = brms.bf(formula)
if len(priors) > 0:
brms_prior = brms.prior_string(*priors[0])
for p in priors[1:]:
brms_prior = brms_prior + brms.prior_string(*p)
assert brms.is_brmsprior(brms_prior)
else:
brms_prior = []
model_code = get_stan_code(
formula=formula,
data=data,
family=family,
priors=brms_prior,
sample_prior=sample_prior,
)
fname = name if name is not None else 'model'
stan_file = f'{outdir}/{fname}.stan'
with open(os.path.abspath(stan_file), 'w') as f:
f.write(model_code)
kwargs = {'stan_file': stan_file}
# load precompiled executable
else:
with open(os.path.abspath(f'{stan_exe_file}.stan'), 'r') as f:
model_code = f.read()
# allow model name to differ from exe name --
# this is essential if using same exe to sample given multiple datasets in parallel
# but depends on removing this check from `cmdstanpy`
name = name if name is not None else stan_exe_file
kwargs = {'exe_file': stan_exe_file, 'compile': False}
model_data = _convert_R_to_python(formula, data, family)
model_data = _coerce_types(model_code, model_data)
sm = cmdstanpy.CmdStanModel(model_name=name, **kwargs)
if not sample:
return sm
else:
fit = sm.sample(data=model_data, output_dir=outdir, **stan_args)
return fit
from bebi103.stan import disable_logging as be_quiet_stan
from bebi103.stan import check_all_diagnostics
from srep.utils import load_FISH_by_promoter
repo = Repo("./", search_parent_directories=True)
# repo_rootdir holds the absolute path to the top-level of our repo
repo_rootdir = repo.working_tree_dir
# first load data using module util
df_unreg, = load_FISH_by_promoter(("unreg", ))
# pull out one specific promoter for convenience for prior pred check & SBC
df_UV5 = df_unreg[df_unreg["experiment"] == "UV5"]
sm = cmdstanpy.CmdStanModel(
stan_file=f"{repo_rootdir}/code/stan/constit_post_inf.stan",
compile=True,
)
all_samples = {}
for gene in df_unreg['experiment'].unique():
temp_df = df_unreg[df_unreg['experiment'] == gene]
stan_data = dict(
N=len(temp_df),
mRNA_counts=temp_df["mRNA_cell"].values.astype(int),
ppc=0 # if you produce ppc samples, the InferenceData obj is HUGE
)
with be_quiet_stan():
posterior_samples = sm.sample(data=stan_data, chains=6)
all_samples[gene] = az.from_cmdstanpy(
posterior_samples, posterior_predictive=["mRNA_counts_ppc"])
print(f"For promoter {gene}...")
with open("data/generated_data/param_summary.pkl", "rb") as file:
params = pickle.load(file)
# Now that we have drawn covariates via LHS, we can simulate some outcomes from subjects with those covariates.
# I will generate some more PK params, simulate possible outcomes, and compute rewards under the sampled doses.
domain_df = pd.read_csv('data/generated_data/hypercube_sampled_covariates.csv')
sampled_covars_dict = domain_df.to_dict(orient="list")
# Combine the LH sampled covars and the model parameters into a single dictionary.
# Set n so Stan can make all the covars in one go.
params = {**sampled_covars_dict, **params}
params["n_subjects"] = domain_df.shape[0]
# This model is capable of generating PK parameters for subjects given the posterior from the
# original model in step 01.
generative_model = cmdstanpy.CmdStanModel(
exe_file="experiment_models/draw_pk_parameters")
# Now sample to get the PK params
fit = generative_model.sample(params,
fixed_param=True,
iter_sampling=1,
seed=19920908)
# Append the pk params. These are all I need to generate observations and pk curves
domain_df["cl"] = fit.stan_variable("cl").squeeze()
domain_df["ke"] = fit.stan_variable("ke").squeeze()
domain_df["ka"] = fit.stan_variable("ka").squeeze()
domain_df["alpha"] = fit.stan_variable("alpha").squeeze()
# Here is where we sample possible outcomes for each simulated subject.
# Because I know their PK parameters, I can ask myself "what could I resonably expect to see under my model at t=tobs"
def _create_test_data():
"""Create test data to local folder.
This function is needed when test data needs to be updated.
"""
import platform
import shutil
from pathlib import Path
import cmdstanpy
model_code = """
data {
int<lower=0> J;
real y[J];
real<lower=0> sigma[J];
}
parameters {
real mu;
real<lower=0> tau;
real eta[J];
}
transformed parameters {
real theta[J];
for (j in 1:J)
theta[j] = mu + tau * eta[j];
}
model {
mu ~ normal(0, 5);
tau ~ cauchy(0, 5);
eta ~ normal(0, 1);
y ~ normal(theta, sigma);
}
generated quantities {
vector[J] log_lik;
vector[J] y_hat;
for (j in 1:J) {
log_lik[j] = normal_lpdf(y[j] | theta[j], sigma[j]);
y_hat[j] = normal_rng(theta[j], sigma[j]);
}
}
"""
stan_file = "stan_test_data.stan"
with open(stan_file, "w") as file_handle:
print(model_code, file=file_handle)
model = cmdstanpy.CmdStanModel(stan_file=stan_file)
os.remove(stan_file)
stan_data = {
"J": 8,
"y": np.array([28.0, 8.0, -3.0, 7.0, -1.0, 1.0, 18.0, 12.0]),
"sigma": np.array([15.0, 10.0, 16.0, 11.0, 9.0, 11.0, 10.0, 18.0]),
}
fit_no_warmup = model.sample(data=stan_data,
iter_sampling=100,
iter_warmup=1000,
save_warmup=False)
fit_no_warmup.save_csvfiles(dir=".")
fit_files = {
"cmdstanpy_eight_schools_nowarmup": [],
"cmdstanpy_eight_schools_warmup": [],
}
for path in fit_no_warmup.runset.csv_files:
path = Path(path)
_, num = path.stem.rsplit("-", 1)
new_path = path.parent / ("cmdstanpy_eight_schools_nowarmup-" + num +
path.suffix)
shutil.move(path, new_path)
fit_files["cmdstanpy_eight_schools_nowarmup"].append(new_path)
fit_warmup = model.sample(data=stan_data,
iter_sampling=100,
iter_warmup=500,
save_warmup=True)
fit_warmup.save_csvfiles(dir=".")
for path in fit_no_warmup.runset.csv_files:
path = Path(path)
_, num = path.stem.rsplit("-", 1)
new_path = path.parent / ("cmdstanpy_eight_schools_warmup-" + num +
path.suffix)
shutil.move(path, new_path)
fit_files["cmdstanpy_eight_schools_warmup"].append(new_path)
path = Path(stan_file)
os.remove(
str(path.parent /
(path.stem + (".exe" if platform.system() == "Windows" else ""))))
os.remove(str(path.parent / (path.stem + ".hpp")))
return fit_files
glucose_data = glucose_data[glucose_data['compound'].isin(
['glucose', 'acetate'])][[
'replicate', 'od_600nm', 'compound', 'rel_area_phosphate', 'date',
'carbon_source'
]]
acetate_data = acetate_data[acetate_data['compound'] == 'acetate'][[
'replicate', 'od_600nm', 'compound', 'rel_area_phosphate', 'date',
'carbon_source'
]]
# Merge the turnover measurements and save
turnover = pd.concat([glucose_data, acetate_data], sort=False)
turnover.to_csv('../../data/collated_turnover_measurements.csv', index=False)
# %%
# Load and compile the inferrential model
model = cmdstanpy.CmdStanModel(
stan_file='../stan/hierarchical_yield_coefficient.stan')
# %%
# Define the percentiles to compute
percs = [(2.5, 97.5), (12.5, 87.5), (25, 75), (37.5, 62.5), (47.5, 52.5)]
perc_labels = [95, 75, 50, 25, 5]
# Group by strain, carbon source, and then compound
param_samples, conc_samples = [], []
param_summary, conc_summary = pd.DataFrame([]), pd.DataFrame([])
yield_fits, calib_fits = [], []
for g, d in turnover.groupby(['carbon_source', 'compound']):
# Get the correct calibration data
calib = calib_data[calib_data['compound'] == g[1]]
def test_stan_concentration_function():
# Test if my stan model and my analytical calculation fo the concentration function match up
model_code='''
functions{
vector heaviside(vector t){
vector[size(t)] y;
for(i in 1:size(t)){
y[i] = t[i]<=0 ? 0 : 1;
}
return y;
}
vector conc(real D, vector t, real Cl, real ka, real ke){
return heaviside(t) .* (exp(-ka*t) - exp(-ke*t)) * (0.5 * D * ke * ka ) / (Cl *(ke - ka));
}
}
data{
int nt;
vector[nt] t;
real cl;
real ka;
real ke;
int n_doses;
vector[n_doses] dose_times;
vector[n_doses] doses;
}
model{}
generated quantities{
vector[nt] C = rep_vector(0.0, nt);
for(i in 1:n_doses){
C += conc(doses[i], t - dose_times[i], cl, ka, ke);
}
}
'''
model_dir = '/tmp/test_model.stan'
with open(model_dir, 'w') as f:
f.write(model_code)
t = np.arange(0, 48.05, 0.05).tolist()
nt = len(t)
cl = 3.3
ka = 1.0
ke = 0.2
dose_times = np.arange(0, 48+12, 12).tolist()
doses = np.tile(10, len(dose_times)).tolist()
n_doses = len(dose_times)
model = cmdstanpy.CmdStanModel(stan_file = model_dir)
model_data = dict(t=t, cl=cl, ka=ka, ke=ke, dose_times=dose_times, doses=doses, nt=nt, n_doses=n_doses)
conc_from_stan = model.sample(model_data, fixed_param=True, iter_sampling=1).stan_variable("C").ravel()
repeat_dose_conc = repeated_dose_concentration(cl, ke, ka)
conc_from_analytical = repeat_dose_conc(np.array(t), np.array(dose_times), np.array(doses))
np.testing.assert_allclose(conc_from_analytical, conc_from_stan, rtol = 1e-4, atol = 1e-4)
import cmdstanpy
import numpy as np
import pickle
import warnings
from scipy.stats import gamma, norm
from typing import List, Dict
# Dictionary of parameters to be used in models. Prevents me from having to
# Manually enter prior params. See step 01
with open('data/generated_data/param_summary.pkl', 'rb') as file:
_params = pickle.load(file)
# # This model is the prior predictive check. Give it covariates and it will give you predictions
_prior_model = cmdstanpy.CmdStanModel(
exe_file='experiment_models/prior_predictive')
_prior_tdm_model = cmdstanpy.CmdStanModel(
exe_file='experiment_models/tdm_prior_predictive')
# # This model fits to simulated data. Give it covariates and observed data and it will give you predictions.
_conditioning_model = cmdstanpy.CmdStanModel(
exe_file='experiment_models/condition_on_patients')
_tdm_model = cmdstanpy.CmdStanModel(
exe_file='experiment_models/bayesian_tdm_single_subject')
def validate_input(x) -> np.ndarray:
'''
Helper function to turn lists into arrays when I pass arguments to functions.
Just cuts down on me writing np.array.
'''
import cmdstanpy
import os
# Compile models to be used
model_files = ('experiment_models/' + file
for file in os.listdir('experiment_models')
if file.endswith('.stan'))
for model in model_files:
print(f'\n\ncompiling {model}\n\n')
cmdstanpy.CmdStanModel(stan_file=model)
def predict(
mi: MaudInput,
output_dir: str,
idata_train: az.InferenceData,
) -> az.InferenceData:
"""Call CmdStanModel.sample for out of sample predictions.
:param mi: a MaudInput object
:param output_dir: directory where output will be saved
:param idata_train: InferenceData object with posterior draws
"""
model = cmdstanpy.CmdStanModel(
stan_file=os.path.join(HERE, STAN_PROGRAM_RELATIVE_PATH_PREDICT),
cpp_options=mi.config.cpp_options,
stanc_options=mi.config.stanc_options,
)
set_up_output_dir(output_dir, mi)
kinetic_parameters = [
"keq",
"km",
"kcat",
"dissociation_constant",
"transfer_constant",
"kcat_phos",
"ki",
]
posterior = idata_train.get("posterior")
sample_stats = idata_train.get("sample_stats")
assert posterior is not None
assert sample_stats is not None
chains = sample_stats["chain"]
draws = sample_stats["draw"]
dims = {
"conc": ["experiment", "mic"],
"conc_enzyme": ["experiment", "enzyme"],
"flux": ["experiment", "reaction"],
}
for chain in chains:
for draw in draws:
inits = {
par: (
posterior[par]
.sel(chain=chain, draw=draw)
.to_series()
.values
)
for par in kinetic_parameters
if par in posterior.keys()
}
sample_args: dict = {
"data": os.path.join(output_dir, "input_data_test.json"),
"inits": inits,
"output_dir": output_dir,
"iter_warmup": 0,
"iter_sampling": 1,
"fixed_param": True,
"show_progress": False,
}
if mi.config.cmdstanpy_config_predict is not None:
sample_args = {
**sample_args,
**mi.config.cmdstanpy_config_predict,
}
mcmc_draw = model.sample(**sample_args)
idata_draw = az.from_cmdstan(
mcmc_draw.runset.csv_files,
coords={
"experiment": [
e.id for e in mi.measurements.experiments if e.is_test
],
"mic": [m.id for m in mi.kinetic_model.mics],
"enzyme": [e.id for e in mi.kinetic_model.enzymes],
"reaction": [r.id for r in mi.kinetic_model.reactions],
},
dims=dims,
).assign_coords(
coords={"chain": [chain], "draw": [draw]},
groups="posterior_groups",
)
if draw == 0:
idata_chain = idata_draw.copy()
else:
idata_chain = az.concat(
[idata_chain, idata_draw], dim="draw", reset_dim=False
)
if chain == 0:
out = idata_chain.copy()
else:
out = az.concat([out, idata_chain], dim="chain", reset_dim=False)
return out
from git import Repo #for directory convenience
import numpy as np
import cmdstanpy
import arviz as az
repo = Repo("./", search_parent_directories=True)
# repo_rootdir holds the absolute path to the top-level of our repo
repo_rootdir = repo.working_tree_dir
sm_gaussF = cmdstanpy.CmdStanModel(
stan_file=f"{repo_rootdir}/code/stan/test_gaussF.stan",
compile=True,)
# stan needs to know how many data points to generate,
# so pick a representative promoter
stan_data = dict(
a=22.35,
b=-17.3,
c=12.5,
z=-1.59,
)
stan_output = sm_gaussF.sample(
data=stan_data,
fixed_param=True,
iter_sampling=1,
)
# Convert to ArviZ InferenceData object
repo = Repo("./", search_parent_directories=True)
# repo_rootdir holds the absolute path to the top-level of our repo
repo_rootdir = repo.working_tree_dir
# first load data using module util
df_unreg, = load_FISH_by_promoter(("unreg", ))
# pull out one specific promoter for convenience for prior pred check & SBC
df_UV5 = df_unreg[df_unreg["experiment"] == "UV5"]
# ############################################################################
# PRIOR PREDICTIVE CHECK
# ############################################################################
sm_prior_pred = cmdstanpy.CmdStanModel(
stan_file=f"{repo_rootdir}/code/stan/constit_prior_pred.stan",
compile=True,
)
# stan needs to know how many data points to generate,
# so pick a representative promoter
data_prior_pred = dict(N=len(df_UV5))
prior_pred_samples = sm_prior_pred.sample(
data=data_prior_pred,
fixed_param=True,
iter_sampling=1000,
)
# Convert to ArviZ InferenceData object
prior_pred_samples = az.from_cmdstanpy(
posterior=prior_pred_samples, # this line b/c of arviz bug, PR#979
#%%
fig, ax = plt.subplots(1, 1)
x = np.linspace(0, 200)
for sample in range(samples):
prior_dist = stats.lognorm(prior_scale[sample], prior_shape[sample])
ax.plot(x, prior_dist.pdf(x), 'r-', alpha=0.05)
#%%
# Build Model
file_path = os.path.join(os.getcwd(), 'model_1.stan')
model = cmdstanpy.CmdStanModel(stan_file=file_path)
model.name
model.stan_file
model.exe_file
print(model.code())
#%%
# Sample
stan_data = {'N': claims.shape[0], 'claims': claims.tolist()}
fit = model.sample(data=stan_data) #, output_dir='./model_output')
print(fit)
print(fit.sample.shape)
