def test_sample(self):
# setup backend
dummy = 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)
# define a distance function
dist_calc = Euclidean(stat_calc)
# create fake observed data
y_obs = [np.array(9.8)]
# use the rejection sampling scheme
sampler = RejectionABC([self.model], [dist_calc], dummy, seed=1)
journal = sampler.sample([y_obs], 10, 1, 10)
mu_sample = np.array(journal.get_parameters()['mu'])
sigma_sample = np.array(journal.get_parameters()['sigma'])
# test shape of samples
self.assertEqual(np.shape(mu_sample), (10, 1))
self.assertEqual(np.shape(sigma_sample), (10, 1))
# Compute posterior mean
#self.assertAlmostEqual(np.average(np.asarray(samples[:,0])),1.22301,10e-2)
self.assertLess(np.average(mu_sample) - 1.22301, 1e-2)
self.assertLess(np.average(sigma_sample) - 6.992218, 10e-2)
self.assertFalse(journal.number_of_simulations == 0)
def infer_parameters_rejectionabc():
# 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 RejectionABC
sampler = RejectionABC([height_weight_model], [distance_calculator], backend, seed=1)
n_samples, n_samples_per_param, epsilon = 2, 1, 20000
print('RejectionABC Inferring')
journal = sampler.sample([y_obs], n_samples, n_samples_per_param, epsilon)
return journal
def test_sample(self):
# setup backend
dummy = 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)
# define a distance function
dist_calc = Euclidean(stat_calc)
# create fake observed data
y_obs = model.simulate(1)
# use the rejection sampling scheme
sampler = RejectionABC(model, dist_calc, dummy, seed=1)
journal = sampler.sample(y_obs, 10, 1, 0.1)
samples = journal.get_parameters()
# test shape of samples
samples_shape = np.shape(samples)
self.assertEqual(samples_shape, (10, 2))
# Compute posterior mean
self.assertEqual((np.average(np.asarray(
samples[:, 0])), np.average(np.asarray(samples[:, 1]))),
(1.6818856447333246, 8.4384177826766518))
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 infer_parameters(backend,
scheme='rejection',
n_samples=250,
n_samples_per_param=10,
logging_level=logging.WARN):
"""Perform inference for this example.
Parameters
----------
backend
The parallelization backend
steps : integer, optional
Number of iterations in the sequential PMCABC algoritm ("generations"). The default value is 3
n_samples : integer, optional
Number of posterior samples to generate. The default value is 250.
n_samples_per_param : integer, optional
Number of data points in each simulated data set. The default value is 10.
Returns
-------
abcpy.output.Journal
A journal containing simulation results, metadata and optionally intermediate results.
"""
logging.basicConfig(level=logging_level)
# experimental setup
T = 50. # simulation time
dt = 0.025 # time step
I_amp = 0.32 # stimulus amplitude
r_soma = 40 # radius of soma
threshold = -55 # AP threshold
# input stimulus
stimulus_dict = constant_stimulus(I_amp=I_amp,
T=T,
dt=dt,
t_stim_on=10,
t_stim_off=40,
r_soma=r_soma)
I = stimulus_dict["I"]
#I_stim = stimulus_dict["I_stim"]
# true parameters
gbar_K_true = 36
gbar_Na_true = 120
gbar_K_std = 5
gbar_Na_std = 5
# define priors
gbar_K = Normal([[gbar_K_true], [gbar_K_std]], name='gbar_K')
gbar_Na = Normal([[gbar_Na_true], [gbar_Na_std]], name='gbar_Na')
# define the model
hh_simulator = HHSimulator([gbar_K, gbar_Na], I, T, dt)
# observed data
obs_data = hh_simulator.forward_simulate([gbar_K_true, gbar_Na_true])
# define statistics
statistics_calculator = Identity()
# Learn the optimal summary statistics using Semiautomatic summary selection
statistics_learning = Semiautomatic([hh_simulator],
statistics_calculator,
backend,
n_samples=1000,
n_samples_per_param=1,
seed=42)
new_statistics_calculator = statistics_learning.get_statistics()
# define distance
distance_calculator = Euclidean(new_statistics_calculator)
# define kernel
kernel = DefaultKernel([gbar_K, gbar_Na])
# define sampling scheme
if scheme == 'rejection':
sampler = RejectionABC([hh_simulator], [distance_calculator],
backend,
seed=42)
# sample from scheme
epsilon = 2.
journal = sampler.sample([obs_data], n_samples, n_samples_per_param,
epsilon)
elif scheme == 'smc':
sampler = SMCABC([hh_simulator], [distance_calculator],
backend,
kernel,
seed=42)
# sample from scheme
steps = 3
journal = sampler.sample([obs_data], steps, n_samples,
n_samples_per_param)
elif scheme == 'pmc':
sampler = PMCABC([hh_simulator], [distance_calculator],
backend,
kernel,
seed=42)
# sample from scheme
steps = 3
eps_arr = np.array([2.])
epsilon_percentile = 10
journal = sampler.sample([obs_data], steps, eps_arr, n_samples,
n_samples_per_param, epsilon_percentile)
return journal
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