def infer_parameters_apmcabc():
# define observation for true parameters mean=170, 65
rng = np.random.RandomState(seed=1)
y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2, ))]
# define prior
from abcpy.continuousmodels import Uniform
mu0 = Uniform([[150], [200]], name="mu0")
mu1 = Uniform([[25], [100]], name="mu1")
# define the model
height_weight_model = NestedBivariateGaussian([mu0, mu1])
# define statistics
from abcpy.statistics import Identity
statistics_calculator = Identity(degree=2, cross=False)
# define distance
from abcpy.distances import Euclidean
distance_calculator = Euclidean(statistics_calculator)
# define sampling scheme
from abcpy.inferences import APMCABC
sampler = APMCABC([height_weight_model], [distance_calculator], backend, seed=1)
steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor, full_output, journal_file = 2, 100, 1, 0.2, 0.03, 2.0, 1, None
print('APMCABC Inferring')
journal = sampler.sample([y_obs], steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor,
full_output, journal_file)
return journal
def ABC_inference(algorithm, model, observation, distance_calculator, eps, n_samples, n_steps, backend, seed=None,
full_output=0, kernel=None, **kwargs):
start = time()
if algorithm == "PMCABC":
sampler = PMCABC([model], [distance_calculator], backend, seed=seed, kernel=kernel)
jrnl = sampler.sample([[observation]], n_steps, np.array([eps]), n_samples=n_samples, full_output=full_output,
**kwargs)
if algorithm == "APMCABC":
sampler = APMCABC([model], [distance_calculator], backend, seed=seed, kernel=kernel)
jrnl = sampler.sample([[observation]], n_steps, n_samples=n_samples, full_output=full_output, **kwargs)
elif algorithm == "SABC":
sampler = SABC([model], [distance_calculator], backend, seed=seed, kernel=kernel)
jrnl = sampler.sample([[observation]], n_steps, eps, n_samples=n_samples, full_output=full_output, **kwargs)
elif algorithm == "SMCABC":
sampler = SMCABC([model], [distance_calculator], backend, seed=seed, kernel=kernel)
jrnl = sampler.sample([[observation]], n_steps, n_samples=n_samples, full_output=full_output, **kwargs)
elif algorithm == "RejectionABC":
sampler = RejectionABC([model], [distance_calculator], backend, seed=seed)
jrnl = sampler.sample([[observation]], epsilon=eps, n_samples=n_samples, n_samples_per_param=1,
full_output=full_output, **kwargs)
elif algorithm == "ABCsubsim":
sampler = ABCsubsim([model], [distance_calculator], backend, seed=seed, kernel=kernel)
# chain_length=10, ap_change_cutoff=10
jrnl = sampler.sample([[observation]], steps=n_steps, n_samples=n_samples, n_samples_per_param=1,
full_output=full_output, **kwargs)
print("It took ", time() - start, " seconds.")
return jrnl
def test_sample(self):
# use the APMCABC scheme for T = 1
steps, n_sample, n_simulate = 1, 10, 1
sampler = APMCABC(self.model,
self.dist_calc,
self.kernel,
self.backend,
seed=1)
journal = sampler.sample(self.observation, steps, n_sample, n_simulate)
samples = (journal.get_parameters(), journal.get_weights())
# Compute posterior mean
mu_post_sample, sigma_post_sample, post_weights = np.asarray(
samples[0][:, 0]), np.asarray(samples[0][:, 1]), np.asarray(
samples[1][:, 0])
mu_post_mean, sigma_post_mean = np.average(
mu_post_sample,
weights=post_weights), np.average(sigma_post_sample,
weights=post_weights)
# test shape of sample
mu_sample_shape, sigma_sample_shape, weights_sample_shape = np.shape(
mu_post_sample), np.shape(mu_post_sample), np.shape(post_weights)
self.assertEqual(mu_sample_shape, (10, ))
self.assertEqual(sigma_sample_shape, (10, ))
self.assertEqual(weights_sample_shape, (10, ))
#self.assertEqual((mu_post_mean, sigma_post_mean), (,))
# use the APMCABC scheme for T = 2
T, n_sample, n_simulate = 2, 10, 1
sampler = APMCABC(self.model,
self.dist_calc,
self.kernel,
self.backend,
seed=1)
journal = sampler.sample(self.observation, T, n_sample, n_simulate)
samples = (journal.get_parameters(), journal.get_weights())
# Compute posterior mean
mu_post_sample, sigma_post_sample, post_weights = np.asarray(
samples[0][:, 0]), np.asarray(samples[0][:, 1]), np.asarray(
samples[1][:, 0])
mu_post_mean, sigma_post_mean = np.average(
mu_post_sample,
weights=post_weights), np.average(sigma_post_sample,
weights=post_weights)
# test shape of sample
mu_sample_shape, sigma_sample_shape, weights_sample_shape = np.shape(
mu_post_sample), np.shape(mu_post_sample), np.shape(post_weights)
self.assertEqual(mu_sample_shape, (10, ))
self.assertEqual(sigma_sample_shape, (10, ))
self.assertEqual(weights_sample_shape, (10, ))
self.assertLess(mu_post_mean - (2.19137364411), 10e-2)
self.assertLess(sigma_post_mean - 5.66226403628, 10e-2)
def test_sample(self):
# use the APMCABC scheme for T = 1
steps, n_sample, n_simulate = 1, 10, 1
sampler = APMCABC([self.model], [self.dist_calc], self.backend, seed=1)
journal = sampler.sample([self.observation],
steps,
n_sample,
n_simulate,
alpha=.9)
mu_post_sample, sigma_post_sample, post_weights = np.array(
journal.get_parameters()['mu']), np.array(
journal.get_parameters()['sigma']), np.array(
journal.get_weights())
# Compute posterior mean
mu_post_mean, sigma_post_mean = journal.posterior_mean(
)['mu'], journal.posterior_mean()['sigma']
# test shape of sample
mu_sample_shape, sigma_sample_shape, weights_sample_shape = (len(mu_post_sample), mu_post_sample[0].shape[1]), \
(len(sigma_post_sample),
sigma_post_sample[0].shape[1]), post_weights.shape
self.assertEqual(mu_sample_shape, (10, 1))
self.assertEqual(sigma_sample_shape, (10, 1))
self.assertEqual(weights_sample_shape, (10, 1))
self.assertFalse(journal.number_of_simulations == 0)
# use the APMCABC scheme for T = 2
T, n_sample, n_simulate = 2, 10, 1
sampler = APMCABC([self.model], [self.dist_calc], self.backend, seed=1)
journal = sampler.sample([self.observation],
T,
n_sample,
n_simulate,
alpha=.9)
mu_post_sample, sigma_post_sample, post_weights = np.array(
journal.get_parameters()['mu']), np.array(
journal.get_parameters()['sigma']), np.array(
journal.get_weights())
# Compute posterior mean
mu_post_mean, sigma_post_mean = journal.posterior_mean(
)['mu'], journal.posterior_mean()['sigma']
# test shape of sample
mu_sample_shape, sigma_sample_shape, weights_sample_shape = (len(mu_post_sample), mu_post_sample[0].shape[1]), \
(len(sigma_post_sample),
sigma_post_sample[0].shape[1]), post_weights.shape
self.assertEqual(mu_sample_shape, (10, 1))
self.assertEqual(sigma_sample_shape, (10, 1))
self.assertEqual(weights_sample_shape, (10, 1))
self.assertLess(mu_post_mean - (-3.397848324005792), 10e-2)
self.assertLess(sigma_post_mean - 6.451434816944525, 10e-2)
self.assertFalse(journal.number_of_simulations == 0)
def test_sample(self):
# use the APMCABC scheme for T = 1
steps, n_sample, n_simulate = 1, 10, 1
sampler = APMCABC([self.model], [self.dist_calc], self.backend, seed=1)
journal = sampler.sample([self.observation], steps, n_sample,
n_simulate)
mu_post_sample, sigma_post_sample, post_weights = np.array(
journal.get_parameters()['mu']), np.array(
journal.get_parameters()['sigma']), np.array(
journal.get_weights())
# Compute posterior mean
mu_post_mean, sigma_post_mean = np.average(mu_post_sample,
weights=post_weights,
axis=0), np.average(
sigma_post_sample,
weights=post_weights,
axis=0)
# test shape of sample
mu_sample_shape, sigma_sample_shape, weights_sample_shape = np.shape(
mu_post_sample), np.shape(mu_post_sample), np.shape(post_weights)
self.assertEqual(mu_sample_shape, (10, 1))
self.assertEqual(sigma_sample_shape, (10, 1))
self.assertEqual(weights_sample_shape, (10, 1))
self.assertFalse(journal.number_of_simulations == 0)
# use the APMCABC scheme for T = 2
T, n_sample, n_simulate = 2, 10, 1
sampler = APMCABC([self.model], [self.dist_calc], self.backend, seed=1)
journal = sampler.sample([self.observation], T, n_sample, n_simulate)
mu_post_sample, sigma_post_sample, post_weights = np.array(
journal.get_parameters()['mu']), np.array(
journal.get_parameters()['sigma']), np.array(
journal.get_weights())
# Compute posterior mean
mu_post_mean, sigma_post_mean = np.average(mu_post_sample,
weights=post_weights,
axis=0), np.average(
sigma_post_sample,
weights=post_weights,
axis=0)
# test shape of sample
mu_sample_shape, sigma_sample_shape, weights_sample_shape = np.shape(
mu_post_sample), np.shape(mu_post_sample), np.shape(post_weights)
self.assertEqual(mu_sample_shape, (10, 1))
self.assertEqual(sigma_sample_shape, (10, 1))
self.assertEqual(weights_sample_shape, (10, 1))
self.assertLess(mu_post_mean - (-2.785), 10e-2)
self.assertLess(sigma_post_mean - 6.2058, 10e-2)
self.assertFalse(journal.number_of_simulations == 0)
# Define distance and statistics
statistics_calculator = Identity(degree = 1, cross = False)
distance_calculator = Abserror(statistics_calculator)
# Define kernel
from abcpy.backends import BackendMPI as Backend
backend = Backend()
from abcpy.perturbationkernel import DefaultKernel
kernel = DefaultKernel([theta1, theta2])
######### Inference for simulated data ###############
water_obs = [np.load('Data/obs_data.npy')]
sampler = APMCABC([water], [distance_calculator], backend, kernel, seed = 1)
steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor, full_output, journal_file =10, 100, 1, 0.1, 0.03, 2.0, 1, None
print('TIP4P: APMCABC Inferring for simulated data')
journal_apmcabc = sampler.sample([water_obs], steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor, full_output, journal_file)
print('TIP4P: APMCABC done for simulated data')
journal_apmcabc.save('Result/MD_GROMACS_APMCABC_obs.jrnl')
######### Inference for Experimental data 1 (Neutron Diffraction of Water) ###############
water_obs = [np.load('Data/exp_data.npy')]
sampler = APMCABC([water], [distance_calculator], backend, kernel, seed = 1)
steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor, full_output, journal_file =10, 100, 1, 0.1, 0.03, 2.0, 1, None
print('TIP4P: APMCABC Inferring for experimental data 1')
journal_apmcabc = sampler.sample([water_obs], steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor, full_output, journal_file)
# DistanceType3 is a measure which determine how close are the peaks both in maximum size and in location
# DistanceType4 is the Euclidean distance between pedestrian position at each time step
from Distance import DistanceType1
distance_calculator = DistanceType1(statistics_calculator)
# Check whether the distance works
if distance_calculator.distance(resultfakeobs1, resultfakeobs1)==distance_calculator.distance(resultfakeobs1, resultfakeobs2):
print('Something may be wrong with the distance!')
###############################################################################
# APMCABC #
###############################################################################
if abc_method=='apmcabc':
from abcpy.inferences import APMCABC
sampler = APMCABC([ff], [distance_calculator], backend, kernel, seed = 1)
steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor, full_output, journal_file = 4, 1000, 1, 0.1, 0.03, 2, 1.0, None
print('APMCABC Inferring')
# We use resultfakeobs1 as our observed dataset
journal_apmcabc = sampler.sample([resultfakeobs1], steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor, full_output, journal_file)
print(journal_apmcabc.posterior_mean())
journal_apmcabc.save('apmcabc_' + sim_model + '_' + exp_dataset + '.jrnl')
###############################################################################
# SABC #
###############################################################################
if abc_method=='sabc':
from abcpy.inferences import SABC
sampler = SABC([ff], [distance_calculator], backend, kernel, seed = 1)
steps, epsilon, n_samples, n_samples_per_param, beta, delta, v, ar_cutoff, resample, n_update, adaptcov, full_output, journal_file = 2, 40, 1000, 1, 2, 0.2, 0.3, 0.5, None, None, 1, 0, None
# define statistics
# from abcpy.statistics import Identity
# statistics_calculator = Identity(degree=1, cross=False)
from Statistics import NeuralEmbeddingStatistics
from Statistics import load_net
from distance_learning.networks import EmbeddingNet
# Here we load the network and pass it to the statistics calculator
embedding_net_triplet = load_net("saved-networks/triplet.pth", EmbeddingNet)
embedding_net_triplet.eval()
statistics_calculator = NeuralEmbeddingStatistics(embedding_net_triplet, degree=1, cross=False)
# define distance
from Distance import DistanceVolcano
distance_calculator = DistanceVolcano(statistics_calculator)
#print(distance_calculator.distance(fake_data, obs_data))
# # define sampling scheme
# # (seed is not used for now)
from abcpy.inferences import APMCABC
sampler = APMCABC([volcano_model], [distance_calculator], backend, seed=1)
print('sampling')
steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor, full_output, journal_file = 6, 100, 1, 0.1, 0.03, 2.0, 1, None
#steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor, full_output, journal_file = 1, 100, 1, 0.1, 0.03, 2.0, 1, 'VolcanojournalAPMCABC_pululagua.jrnl'
journal = sampler.sample([obs_data], steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor, full_output, journal_file)
journal.save('VolcanojournalAPMCABC_pululagua.jrnl')
beta=2,
delta=0.2,
v=0.3,
ar_cutoff=0.001,
resample=None,
n_update=None,
full_output=1,
journal_file=journal_file)
print(journal_sabc.posterior_mean())
journal_sabc.save(dircertory + "/" + algorithm + '_' + problem +
'_obs.jrnl')
elif algorithm == 'apmcabc':
#APMCABC
from abcpy.inferences import APMCABC
sampler = APMCABC([Bass], [distance_calculator],
backend,
kernel,
seed=1)
steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor, full_output, journal_file = 10, 111, 1, 0.6, 0.001, 2, 1, None
print('APMCABC Inferring')
journal_apmcabc = sampler.sample([obs_data], steps, n_samples,
n_samples_per_param, alpha,
acceptance_cutoff, covFactor,
full_output, journal_file)
print(journal_apmcabc.posterior_mean())
journal_apmcabc.save('apmcabc_' + problem + '_obs.jrnl')
if predict:
# from model import DrawFromPosteriorFile
# dp = DrawFromPosteriorFile([Bass], backend)
# print('Prediction')
# parameters, simulations = dp.sample(file=dircertory + "/"+'rejection_one_pcent.csv')
#distance_calculator = DistanceType4()
distance_calculator = DistanceWeighted()
print(distance_calculator.distance(resultfakeobs1, resultfakeobs2))
# # Check whether the distance works
# if distance_calculator.distance(resultfakeobs1, resultfakeobs1)==distance_calculator.distance(resultfakeobs1, resultfakeobs2):
# print('Something may be wrong with the distance!')
###############################################################################
# APMCABC #
###############################################################################
if abc_method == 'apmcabc':
from abcpy.inferences import APMCABC
sampler = APMCABC([ff], [distance_calculator], backend, kernel, seed=1)
steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor, full_output, journal_file = 4, 10, 1, 0.1, 0.03, 2, 1.0, None
print('APMCABC Inferring')
# We use resultfakeobs1 as our observed dataset
journal_apmcabc = sampler.sample([resultfakeobs1], steps, n_samples,
n_samples_per_param, alpha,
acceptance_cutoff, covFactor, full_output,
journal_file)
print(journal_apmcabc.posterior_mean())
journal_apmcabc.save('apmcabc_' + sim_model + '_' + exp_dataset + '.jrnl')
###############################################################################
# SABC #
###############################################################################
if abc_method == 'sabc':
def ABC_inference(algorithm,
model,
observation,
distance_calculator,
eps,
n_samples,
n_steps,
backend,
seed=None,
full_output=0,
**kwargs):
"""NB: eps represents initial value of epsilon for PMCABC and SABC; represents the single eps value for RejectionABC
and represents the final value for SMCABC."""
start = time()
if algorithm == "PMCABC":
sampler = PMCABC([model], [distance_calculator], backend, seed=seed)
jrnl = sampler.sample([[observation]],
n_steps,
np.array([eps]),
n_samples=n_samples,
full_output=full_output,
**kwargs)
if algorithm == "APMCABC":
sampler = APMCABC([model], [distance_calculator], backend, seed=seed)
jrnl = sampler.sample([[observation]],
n_steps,
n_samples=n_samples,
full_output=full_output,
**kwargs)
elif algorithm == "SABC":
sampler = SABC([model], [distance_calculator], backend, seed=seed)
jrnl = sampler.sample([[observation]],
n_steps,
eps,
n_samples=n_samples,
full_output=full_output,
**kwargs)
elif algorithm == "RejectionABC":
sampler = RejectionABC([model], [distance_calculator],
backend,
seed=seed)
jrnl = sampler.sample([[observation]],
eps,
n_samples=n_samples,
full_output=full_output,
**kwargs)
elif algorithm == "SMCABC":
# for this usually a larger number of steps is required. alpha can be left to 0.95, covFactor=2 and
# resample=None. epsilon_final is instead important to fix!
sampler = SMCABC([model], [distance_calculator], backend, seed=seed)
# sample(observations, steps, n_samples=10000, n_samples_per_param=1, epsilon_final=0.1, alpha=0.95,
# covFactor=2, resample=None, full_output=0, which_mcmc_kernel=0, journal_file=None)
jrnl = sampler.sample([[observation]],
n_steps,
n_samples=n_samples,
full_output=full_output,
epsilon_final=eps,
**kwargs)
print("It took ", time() - start, " seconds.")
return jrnl