import pyabc
from pyABC_study.ODE import ODESolver, PriorLimits, exp_data
print("\n\n\nABC SMC\nParameter estimation\n")
# %% Set database path and observed data
# Change database name every run
db_path = "sqlite:///model3.db"
print("Target data")
print(exp_data)
solver = ODESolver()
# %% Calculate data range as factors:
print("No factors applied")
# %% Plot
# obs_data_plot(solver.timePoint, obs_data_noisy_s, obs_data_raw_s)
# %% Define prior distribution of parameters
# Be careful that RV("uniform", -10, 15) means uniform distribution in [-10, 5], '15' here is the interval length
# Set prior
lim = PriorLimits(1e-6, 75)
para_true = {'iBM': 1.0267462374320455,
'kMB': 0.07345932286118964,
'kNB': 2.359199465995228,
'lambdaM': 2.213837884117815,
'lambdaN': 7.260925726829641,
'muA': 18.94626522780349,
'muB': 2.092860392215201,
'muM': 0.17722330053184654,
'muN': 0.0023917569160019844,
'sAM': 10.228522400429998,
'sBN': 4.034313992927392,
'vNM': 0.3091883041193706}
# Using default time points
solver = ODESolver()
obs_data_noisy = solver.ode_model(para_true, flatten=True, add_noise=True)
obs_data_raw = solver.ode_model(para_true, flatten=True, add_noise=False)
obs_data_noisy_s = solver.ode_model(para_true, flatten=False, add_noise=True)
obs_data_raw_s = solver.ode_model(para_true, flatten=False, add_noise=False)
print("Target data")
print(obs_data_noisy_s)
# %% Calculate data range as factors:
# Use data range as factors
range_N = obs_data_raw_s['N'].max() - obs_data_raw_s['N'].min()
range_M = obs_data_raw_s['M'].max() - obs_data_raw_s['M'].min()
import pyabc
from pyABC_study.ODE import ODESolver, PriorLimits, para_true1, para_prior
print("\n\n\n Base\n Median eps, 2000 particles, 20 generations\n\n\n")
# %% Set path
db_path = "sqlite:///dbfiles/ib_wide.db"
# %% Generate synthetic data
# Using default time points
solver = ODESolver()
solver.time_point = solver.time_point_default
obs_data_raw = solver.ode_model1(para_true1)
print("Target data")
print(obs_data_raw)
# Set factors
# print("Factors applied: 75/25 factor")
# factors = {}
# time_length: int = len(solver.time_point) * 4
# # for i in range(0, time_length, 4):
para_prior3 = para_prior(lim, prior_distribution, 3)
para_prior4 = para_prior(lim, prior_distribution, 4)
para_prior5 = para_prior(lim, prior_distribution, 5)
# %% Load database
# change database name
db_path = "sqlite:///db/model5_24_more.db"
history = pyabc.History(db_path)
print("ID: %d, generations: %d" % (history.id, history.max_t))
# %% Plot
solver = ODESolver()
# change model name
solver.ode_model = solver.ode_model5
result_data(history, solver, nr_population=history.max_t, savefig=True)
# change prior name
result_plot(history, None, para_prior5, history.max_t - 5, savefig=False)
df, w = history.get_distribution(t=history.max_t - 5)
pyabc.visualization.plot_kde_matrix(df, w)
plt.show()
pyabc.visualization.plot_epsilons(history)
plt.show()
import pyabc
from pyABC_study.ODE import ODESolver, PriorLimits, arr2d_to_dict, para_true1, para_prior
from pyABC_study.dataPlot import result_data_old, result_plot, result_data
# %% Settings
lim = PriorLimits(1e-6, 50)
prior_distribution = "uniform"
print(prior_distribution)
para_prior1 = para_prior(lim, prior_distribution, 1)
solver = ODESolver()
solver.time_point = solver.time_point_default
obs_data_raw_s = solver.ode_model1(para_true1, flatten=False, add_noise=False)
solver.time_point = solver.time_point_exp
obs_data_raw_s_less = solver.ode_model(para_true1, flatten=False, add_noise=False)
# print("Target data")
# print(obs_data_noisy_s)
# %% Load database
db_path = "sqlite:///db/abcsmc_test.db"
history = pyabc.History(db_path)
def result_data_old(history,
solver: ODESolver,
compare_data=exp_data_s,
nr_population=1,
sample_size=500,
savefig='False'):
"""
Visualise SMC population from infer-back populations
:param solver: ODE solver object
:param savefig: Filename of output figure. If 'False' then no figure will be saved
:param history: abc.history object
:param compare_data: target data
:param nr_population: the id of population to be visualised
:param sample_size: sampling size of the selected population
"""
df, w = history.get_distribution(t=nr_population)
# df.columns = ['i_beta_phi', 'k_phi_beta', 'k_n_beta', 'lambda_phi', 'lambda_n', 'mu_alpha', 'mu_beta', 'mu_phi',
# 'mu_n', 's_alpha_phi', 's_beta_n', 'v_n_phi']
df_sample = df.sample(sample_size, replace=False)
df_all_sim_data = pd.DataFrame(columns=['N', 'M', 'B', 'A'])
# solver.time_point = solver.time_point_default
for ii in range(sample_size):
temp_dict = df_sample.iloc[ii].to_dict()
sim_data = solver.ode_model(temp_dict, flatten=False)
# print(sim_data)
sim_data = pd.DataFrame.from_dict(sim_data)
df_all_sim_data = pd.concat([df_all_sim_data, sim_data])
# plt.ylim(0, 2) # make lim a function parameter
# plt.show()
df_mean = pd.DataFrame(columns=['N', 'M', 'B', 'A'])
for jj in range(solver.time_point.__len__()):
# print(df_all_sim_data.loc[jj].mean())
df_mean = df_mean.append(df_all_sim_data.loc[jj].mean(),
ignore_index=True)
df_median = quantile_calculate(df_all_sim_data,
solver.time_point.__len__(), 0.5)
df_75 = quantile_calculate(df_all_sim_data, solver.time_point.__len__(),
0.75)
df_25 = quantile_calculate(df_all_sim_data, solver.time_point.__len__(),
0.25)
fig, axs = plt.subplots(4, 1, figsize=(6, 12))
plt.subplots_adjust(hspace=0.5)
index_cov = ['N', 'M', 'B', 'A']
titles = ["N", "Φ", "β", "α"]
for kk in range(4):
# seq_mask = np.isfinite(compare_data[index_cov[kk]])
# axs[kk].plot(solver.timePoint, df_25.iloc[:, kk], 'b--')
# axs[kk].plot(solver.timePoint, df_75.iloc[:, kk], 'b--')
axs[kk].fill_between(solver.time_point,
df_25.iloc[:, kk],
df_75.iloc[:, kk],
alpha=0.9,
color='lightgrey')
axs[kk].plot(solver.time_point,
df_mean.iloc[:, kk],
'b',
label="Mean",
alpha=0.6)
axs[kk].scatter(solver.time_point_default,
compare_data[index_cov[kk]],
alpha=0.7,
marker='^',
color='black')
# axs[kk].errorbar(solver.time_point_exp, compare_data[index_cov[kk]],
# yerr=[[0.5 * x for x in exp_data_SEM[index_cov[kk]]],
# [0.5 * x for x in exp_data_SEM[index_cov[kk]]]], fmt='none',
# ecolor='grey', elinewidth=2, alpha=0.6)
# axs[kk].legend(['Mean', '25% – 75% quantile range', 'Observed'])
axs[kk].set_title(titles[kk])
# fig.tight_layout(pad=5.0)
if savefig != 'False':
plt.savefig(savefig + ".png", dpi=200)
plt.show()
# para_true = {'iBM': 1.0267462374320455,
# 'kMB': 0.07345932286118964,
# 'kNB': 2.359199465995228,
# 'lambdaM': 2.213837884117815,
# 'lambdaN': 7.260925726829641,
# 'muA': 18.94626522780349,
# 'muB': 2.092860392215201,
# 'muM': 0.17722330053184654,
# 'muN': 0.0023917569160019844,
# 'sAM': 10.228522400429998,
# 'sBN': 4.034313992927392,
# 'vNM': 0.3091883041193706}
# Using default time points
solver = ODESolver()
solver.time_point = solver.time_point_default
# obs_data_noisy = solver.ode_model(para_true, flatten=True, add_noise=True)
obs_data_raw = solver.ode_model(para_true1, flatten=True, add_noise=False)
# obs_data_noisy_s = solver.ode_model(para_true1, flatten=False, add_noise=True)
# obs_data_raw_s = solver.ode_model(para_true1, flatten=False, add_noise=False)
print("Target data")
print(obs_data_raw)
# %% Calculate data range as factors:
# range_N = obs_data_raw_s['N'].max() - obs_data_raw_s['N'].min()
# range_M = obs_data_raw_s['M'].max() - obs_data_raw_s['M'].min()
# range_B = obs_data_raw_s['B'].max() - obs_data_raw_s['B'].min()
'v_n_phi': para[11]
}
return para_dict
# Read and prepare raw data
rawData_path = os.path.abspath(os.curdir) + "/data/rawData.csv"
rawData = pd.read_csv(rawData_path).astype("float32")
# normalise_data(expData)
print("Target data")
print(exp_data)
# Run a rough inference on the raw data
solver = ODESolver()
# Reload the timepoints to be calculated in ODE solver
solver.time_point = solver.time_point_exp
paraGuess = [1] * 12
distanceP2 = pyabc.PNormDistance(p=2)
tmpData = solver.ode_model(para_list_to_dict(paraGuess))
def residual_ls(para: list):
"""
Define the residual
:param para: parameter values
:return: value of residual
"""
