def infer_parameters_pmc():
# define observation for true parameters mean=170, 65
rng = np.random.RandomState()
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]], )
mu1 = Uniform([[25], [100]], )
# define the model
height_weight_model = NestedBivariateGaussian([mu0, mu1])
# define statistics
from abcpy.statistics import Identity
statistics_calculator = Identity(degree=2, cross=False)
from abcpy.approx_lhd import SynLiklihood
approx_lhd = SynLiklihood(statistics_calculator)
# define sampling scheme
from abcpy.inferences import PMC
sampler = PMC([height_weight_model], [approx_lhd], backend, seed=1)
# sample from scheme
T, n_sample, n_samples_per_param = 2, 10, 10
journal = sampler.sample([y_obs], T, n_sample, n_samples_per_param)
return journal
def test_sample(self):
# setup backend
backend = BackendDummy()
# define a uniform prior distribution
mu = Uniform([[-5.0], [5.0]], name='mu')
sigma = Uniform([[0.0], [10.0]], name='sigma')
# define a Gaussian model
self.model = Normal([mu,sigma])
# define sufficient statistics for the model
stat_calc = Identity(degree = 2, cross = 0)
# create fake observed data
#y_obs = self.model.forward_simulate(1, np.random.RandomState(1))[0].tolist()
y_obs = [np.array(9.8)]
# Define the likelihood function
likfun = SynLiklihood(stat_calc)
T, n_sample, n_samples_per_param = 1, 10, 100
sampler = PMC([self.model], [likfun], backend, seed = 1)
journal = sampler.sample([y_obs], T, n_sample, n_samples_per_param, covFactors = np.array([.1,.1]), iniPoints = None)
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(abs(mu_post_mean - (-3.402868)), 1e-3)
self.assertLess(abs(sigma_post_mean - 6.212), 1e-3)
self.assertFalse(journal.number_of_simulations == 0)
# use the PMC scheme for T = 2
T, n_sample, n_samples_per_param = 2, 10, 100
sampler = PMC([self.model], [likfun], backend, seed = 1)
journal = sampler.sample([y_obs], T, n_sample, n_samples_per_param, covFactors = np.array([.1,.1]), iniPoints = None)
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(abs(mu_post_mean - (-3.03325763) ), 1e-3)
self.assertLess(abs(sigma_post_mean - 6.92124735), 1e-3)
self.assertFalse(journal.number_of_simulations == 0)
def setUp(self):
self.stat_calc1 = Identity(degree=1, cross=0)
self.stat_calc2 = Identity(degree=1, cross=0)
self.likfun1 = SynLiklihood(self.stat_calc1)
self.likfun2 = SynLiklihood(self.stat_calc2)
## Define Models
# define a uniform prior distribution
self.mu = Uniform([[-5.0], [5.0]], name='mu')
self.sigma = Uniform([[0.0], [10.0]], name='sigma')
# define a Gaussian model
self.model1 = Normal([self.mu, self.sigma])
self.model2 = Normal([self.mu, self.sigma])
#Check whether wrong sized distnacefuncs gives an error
self.assertRaises(ValueError, ProductCombination,
[self.model1, self.model2], [self.likfun1])
self.jointapprox_lhd = ProductCombination([self.model1, self.model2],
[self.likfun1, self.likfun2])
def setUp(self):
self.mu = Uniform([[-5.0], [5.0]], name='mu')
self.sigma = Uniform([[5.0], [10.0]], name='sigma')
self.model = Normal([self.mu, self.sigma])
self.stat_calc = Identity(degree=2, cross=0)
self.likfun = SynLiklihood(self.stat_calc)
def setUp(self):
self.prior = Uniform([-5.0, 5.0], [5.0, 10.0], seed=1)
self.model = Gaussian(self.prior, mu=1.1, sigma=1.0, seed=1)
self.stat_calc = Identity(degree=2, cross=0)
self.likfun = SynLiklihood(self.stat_calc)
def test_sample(self):
# setup backend
backend = BackendDummy()
# define a uniform prior distribution
mu = Uniform([[-5.0], [5.0]], name='mu')
sigma = Uniform([[0.0], [10.0]], name='sigma')
# define a Gaussian model
self.model = Normal([mu, sigma])
# define sufficient statistics for the model
stat_calc = Identity(degree=2, cross=0)
# create fake observed data
#y_obs = self.model.forward_simulate(1, np.random.RandomState(1))[0].tolist()
y_obs = [np.array(9.8)]
# Define the likelihood function
likfun = SynLiklihood(stat_calc)
T, n_sample, n_samples_per_param = 1, 10, 100
sampler = PMC([self.model], [likfun], backend, seed=1)
journal = sampler.sample([y_obs],
T,
n_sample,
n_samples_per_param,
covFactors=np.array([.1, .1]),
iniPoints=None)
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(abs(mu_post_mean - (-3.3711206204663764)), 1e-3)
self.assertLess(abs(sigma_post_mean - 6.518520667688998), 1e-3)
self.assertFalse(journal.number_of_simulations == 0)
# use the PMC scheme for T = 2
T, n_sample, n_samples_per_param = 2, 10, 100
sampler = PMC([self.model], [likfun], backend, seed=1)
journal = sampler.sample([y_obs],
T,
n_sample,
n_samples_per_param,
covFactors=np.array([.1, .1]),
iniPoints=None)
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(abs(mu_post_mean - (-2.970827684425406)), 1e-3)
self.assertLess(abs(sigma_post_mean - 6.82165619013458), 1e-3)
self.assertFalse(journal.number_of_simulations == 0)
def test_sample(self):
# setup backend
backend = BackendDummy()
# define a uniform prior distribution
lb = np.array([-5, 0])
ub = np.array([5, 10])
prior = Uniform(lb, ub, seed=1)
# define a Gaussian model
model = Gaussian(prior, mu=2.1, sigma=5.0, seed=1)
# define sufficient statistics for the model
stat_calc = Identity(degree=2, cross=0)
# create fake observed data
y_obs = model.simulate(1)
# Define the likelihood function
likfun = SynLiklihood(stat_calc)
# use the PMC scheme for T = 1
mean = np.array([-13.0, .0, 7.0])
cov = np.eye(3)
kernel = MultiNormal(mean, cov, seed=1)
T, n_sample, n_samples_per_param = 1, 10, 100
sampler = PMC(model, likfun, kernel, backend, seed=1)
journal = sampler.sample(y_obs,
T,
n_sample,
n_samples_per_param,
covFactor=np.array([.1, .1]),
iniPoints=None)
samples = (journal.get_parameters(), journal.get_weights())
# Compute posterior mean
mu_post_sample, sigma_post_sample, post_weights = np.array(
samples[0][:, 0]), np.array(samples[0][:,
1]), np.array(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(abs(mu_post_mean - (-1.48953333102)), 1e-10)
self.assertLess(abs(sigma_post_mean - 6.50695612708), 1e-10)
# use the PMC scheme for T = 2
T, n_sample, n_samples_per_param = 2, 10, 100
sampler = PMC(model, likfun, kernel, backend, seed=1)
journal = sampler.sample(y_obs,
T,
n_sample,
n_samples_per_param,
covFactor=np.array([.1, .1]),
iniPoints=None)
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(abs(mu_post_mean - (-1.4033145848)), 1e-10)
self.assertLess(abs(sigma_post_mean - 7.05175546876), 1e-10)