def test_composed_prior_sampling(self):
m1 = 10
c1 = 2
p1 = pints.GaussianLogPrior(m1, c1)
m2 = -50
c2 = 100
p2 = pints.GaussianLogPrior(m2, c2)
p = pints.ComposedLogPrior(p1, p2)
p = pints.ComposedLogPrior(p1, p2)
d = 2
n = 1
x = p.sample(n)
self.assertEqual(x.shape, (n, d))
n = 10
x = p.sample(n)
self.assertEqual(x.shape, (n, d))
p = pints.ComposedLogPrior(
p1,
pints.MultivariateGaussianLogPrior([0, 1, 2], np.diag([2, 4, 6])),
p2,
p2,
)
d = p.n_parameters()
self.assertEqual(d, 6)
n = 1
x = p.sample(n)
self.assertEqual(x.shape, (n, d))
n = 10
x = p.sample(n)
self.assertEqual(x.shape, (n, d))
def test_composed_prior(self):
import pints
import numpy as np
m1 = 10
c1 = 2
p1 = pints.GaussianLogPrior(m1, c1)
m2 = -50
c2 = 100
p2 = pints.GaussianLogPrior(m2, c2)
p = pints.ComposedLogPrior(p1, p2)
# Test at center
peak1 = p1([m1])
peak2 = p2([m2])
self.assertEqual(p([m1, m2]), peak1 + peak2)
# Test at random points
np.random.seed(1)
for i in range(100):
x = np.random.normal(m1, c1)
y = np.random.normal(m2, c2)
self.assertAlmostEqual(p([x, y]), p1([x]) + p2([y]))
# Test effect of increasing covariance
p = [
pints.ComposedLogPrior(p1, pints.GaussianLogPrior(m2, c))
for c in range(1, 10)
]
p = [f([m1, m2]) for f in p]
self.assertTrue(np.all(p[:-1] > p[1:]))
# Test errors
self.assertRaises(ValueError, pints.ComposedLogPrior)
self.assertRaises(ValueError, pints.ComposedLogPrior, 1)
# Test derivatives
p = pints.ComposedLogPrior(p1, p2)
x = [8, -40]
y, dy = p.evaluateS1(x)
self.assertEqual(y, p(x))
self.assertEqual(dy.shape, (2, ))
y1, dy1 = p1.evaluateS1(x[:1])
y2, dy2 = p2.evaluateS1(x[1:])
self.assertAlmostEqual(dy[0], dy1[0])
self.assertAlmostEqual(dy[1], dy2[0])
# Test means
m1 = 10
c1 = 2
p1 = pints.GaussianLogPrior(m1, c1)
m2 = -50
c2 = 50
p2 = pints.UniformLogPrior(m2, c2)
p = pints.ComposedLogPrior(p1, p2)
self.assertTrue(np.array_equal(p.mean(), [10, 0]))
def _make_pints_posterior(self):
"""Rebuild the Pints posterior and save it.
"""
# Build a uniform model prior if it is not supplied
if self.model_prior is None:
num_model_params = self.problem.n_parameters()
model_prior = pints.UniformLogPrior([-1e6] * num_model_params,
[1e6] * num_model_params)
# Get the GP prior
kernel_prior = NonstatGPLogPrior(
self.gp_times,
self.kernel.num_parameters() // len(self.gp_times), self.mu,
self.alpha, self.beta)
# Combine the two priors
log_prior = pints.ComposedLogPrior(model_prior, kernel_prior)
# Build the likelihood
log_likelihood = flexnoise.KernelCovarianceLogLikelihood(
self.problem, self.kernel)
# Build the posterior
log_posterior = pints.LogPosterior(log_likelihood, log_prior)
self.posterior = log_posterior
def update_model(self, fixed_parameters_list):
"""
Update the model with fixed parameters.
Parameters
----------
fixed_parameters_list
List of fixed parameter values.
"""
# Create dictionary of fixed parameters and its values
name_value_dict = {
name: value
for (name, value
) in zip(self.model._parameter_names, fixed_parameters_list)
}
self.model.fix_parameters(name_value_dict)
# Setup the problem with pints,
# including likelihood, prior and posterior
print(self.model.n_parameters())
problem = pints.SingleOutputProblem(
model=self.model,
times=self.data['Time'].to_numpy(),
values=self.data['Incidence Number'].to_numpy())
log_likelihood = pints.GaussianLogLikelihood(problem)
priors = self.set_prior(name_value_dict)
self.log_prior = pints.ComposedLogPrior(*priors)
self.log_posterior = pints.LogPosterior(log_likelihood, self.log_prior)
# Run transformation
self.transformations = pints.LogTransformation(
self.log_posterior.n_parameters())
def test_log_posterior(self):
# Create a toy problem and log likelihood
model = pints.toy.LogisticModel()
real_parameters = [0.015, 500]
x = [0.014, 501]
sigma = 0.001
times = np.linspace(0, 1000, 100)
values = model.simulate(real_parameters, times)
problem = pints.SingleOutputProblem(model, times, values)
log_likelihood = pints.GaussianKnownSigmaLogLikelihood(problem, sigma)
# Create a prior
log_prior = pints.UniformLogPrior([0, 0], [1, 1000])
# Test
p = pints.LogPosterior(log_likelihood, log_prior)
self.assertEqual(p(x), log_likelihood(x) + log_prior(x))
y = [-1, 500]
self.assertEqual(log_prior(y), -float('inf'))
self.assertEqual(p(y), -float('inf'))
self.assertEqual(p(y), log_prior(y))
# Test derivatives
log_prior = pints.ComposedLogPrior(pints.GaussianLogPrior(0.015, 0.3),
pints.GaussianLogPrior(500, 100))
log_posterior = pints.LogPosterior(log_likelihood, log_prior)
x = [0.013, 540]
y, dy = log_posterior.evaluateS1(x)
self.assertEqual(y, log_posterior(x))
self.assertEqual(dy.shape, (2, ))
y1, dy1 = log_prior.evaluateS1(x)
y2, dy2 = log_likelihood.evaluateS1(x)
self.assertTrue(np.all(dy == dy1 + dy2))
# Test getting the prior and likelihood back again
self.assertIs(log_posterior.log_prior(), log_prior)
self.assertIs(log_posterior.log_likelihood(), log_likelihood)
# First arg must be a LogPDF
self.assertRaises(ValueError, pints.LogPosterior, 'hello', log_prior)
# Second arg must be a log_prior
self.assertRaises(ValueError, pints.LogPosterior, log_likelihood,
log_likelihood)
# Prior and likelihood must have same dimension
self.assertRaises(ValueError, pints.LogPosterior, log_likelihood,
pints.GaussianLogPrior(0.015, 0.3))
def test_composed_prior_cdf_icdf(self):
p1 = pints.GaussianLogPrior(-3, 7)
p2 = pints.UniformLogPrior(-4, -1)
p = pints.ComposedLogPrior(p1, p2)
ps = [p1, p2]
xs = [-10, -3]
cdfs = p.cdf(xs)
for i, cdf in enumerate(cdfs):
self.assertEqual(cdf, ps[i].cdf(xs[i]))
cdfs1 = p.convert_to_unit_cube(xs)
self.assertEqual(cdfs[0], cdfs1[0])
self.assertEqual(cdfs[1], cdfs1[1])
qs = [0.3, 0.75]
icdfs = p.icdf(qs)
for i, icdf in enumerate(icdfs):
self.assertEqual(icdf, ps[i].icdf(qs[i]))
icdfs1 = p.convert_from_unit_cube(qs)
self.assertEqual(icdfs[0], icdfs1[0])
self.assertEqual(icdfs[1], icdfs1[1])
transform,
sine_wave=1)
n_params = model.n_params
#
# Define problem
#
problem = pints.SingleOutputProblem(model, time, current)
#
# Define log-posterior
#
log_likelihood = LogLikelihood.tiLogLikelihood(problem, sigma_noise, voltage)
log_prior_rates = prior.LogPrior(rate_dict, lower_conductance, n_params,
transform)
log_prior_discrp = pints.NormalLogPrior(0., 1.5)
log_prior = pints.ComposedLogPrior(log_prior_rates, log_prior_discrp)
log_posterior = pints.LogPosterior(log_likelihood, log_prior)
rate_checker = Rates.ratesPrior(transform, lower_conductance)
#
# Run
#
nchains = 1
# Define starting point for mcmc routine
xs = []
x0 = np.loadtxt(cmaes_result_files + model_name + '-cell-' + str(cell) +
'-cmaes.txt')
ds = log_prior_discrp.sample().reshape((1, ))
x0 = [np.concatenate((x0, ds))]
loglikelihood = DiscrepancyLogLikelihood(
problem, inducing_times, downsample=100
) #Note to Chon: downsample=100<--change this to 1 or None when not debugging
logmodelprior = LogPrior[info_id](transform_to_model_param,
transform_from_model_param)
# Priors for discrepancy
# I have transformed all the discrepancy priors as well
lognoiseprior = HalfNormalLogPrior(
sd=25,
transform=True) # This will have considerable mass at the initial value
logrhoprior = InverseGammaLogPrior(
alpha=5, beta=5, transform=True) # As suggested in STAN manual
logkersdprior = InverseGammaLogPrior(
alpha=5, beta=5, transform=True) # As suggested in STAN manual
logprior = pints.ComposedLogPrior(logmodelprior, lognoiseprior, logrhoprior,
logkersdprior)
logposterior = pints.LogPosterior(loglikelihood, logprior)
# Check logposterior is working fine
initial_rho = logrhoprior.sample(
) #np.log(0.5) # Initialise Kernel hyperparameter \rho
initial_ker_sigma = logkersdprior.sample(
) #np.log(5.0) # Initialise Kernel hyperparameter \ker_sigma
priorparams = np.copy(info.base_param)
transform_priorparams = transform_from_model_param(priorparams)
priorparams = np.hstack(
(priorparams, noise_sigma, initial_rho, initial_ker_sigma))
transform_priorparams = np.hstack(
(transform_priorparams, noise_sigma, initial_rho, initial_ker_sigma))
print('Posterior at prior parameters: ', logposterior(transform_priorparams))
n_arama = len(armax_result.params[armax_result.k_exog:])
# Create Pints stuffs
problem = pints.SingleOutputProblem(model, times, data)
loglikelihood = DiscrepancyLogLikelihood(
problem, armax_result, transparams=transparams
) ################# <-----Changed 21/10 #####################
logmodelprior = LogPrior[info_id](transform_to_model_param,
transform_from_model_param)
# Priors for discrepancy
logarmaprior = ArmaNormalCentredLogPrior(
armax_result,
0.25) # Note for Chon: Worth checking out more wider/narrower priors
logprior = pints.ComposedLogPrior(logmodelprior, logarmaprior)
logposterior = pints.LogPosterior(loglikelihood, logprior)
# Check logposterior is working fine
init_arma_ar = _ar_transparams(armax_result.arparams.copy(
)) ################# <-----Changed 21/10 #####################
init_arma_ma = _ma_transparams(armax_result.maparams.copy(
)) ################# <-----Changed 21/10 #####################
init_arma = np.append(
init_arma_ar,
init_arma_ma) ################# <-----Changed 21/10 #####################
priorparams = np.copy(info.base_param)
transform_priorparams = transform_from_model_param(priorparams)
priorparams = np.append(priorparams, init_arma)
transform_priorparams = np.append(transform_priorparams, init_arma)
cmaes_params = np.loadtxt(cmaes_result_files + model_name + '-cell-' +
str(cell) + '-cmaes.txt')
exog_current = model.simulate(cmaes_params, time)
armax_mod = sm.tsa.ARMA(current, order=(2, 1), exog=exog_current)
armax_result = armax_mod.fit(trend='nc', solver='cg')
print(armax_result.summary())
# Define problem for pints
#
problem = pints.SingleOutputProblem(model, time, current)
if args.discrepancy:
log_prior_model_params = prior.LogPrior(rate_dict, lower_conductance,
n_params, transform)
#log_prior_arma = positive_priors.ArmaLogPrior(armax_result, 1e-1)
log_prior_arma = positive_priors.ArmaLogPriorNonPints(armax_result, 0.25)
log_prior = pints.ComposedLogPrior(log_prior_model_params, log_prior_arma)
else:
log_prior = prior.LogPrior(rate_dict, lower_conductance, n_params,
transform)
burnin = args.burnin
iterations = args.niter
do_thermo = args.thermo
if do_thermo:
#
# Define a MCMC runner function that will run a single MCMC chain for a given
# Thermodynamic temperature `t`
#
nchains = 1
num_temps = args.ntemps
def mcmc_runner(temps, n_chains=nchains):
current = data.current
times = data.times
problem = pints.SingleOutputProblem(pints_model, times, current)
boundaries = pints.RectangularBoundaries(lower_bounds, upper_bounds)
# Create a new log-likelihood function (adds an extra parameter!)
log_likelihood = pints.GaussianLogLikelihood(problem)
# Create a new prior
large = 1e9
param_prior = pints.MultivariateGaussianLogPrior(
mu_0, large * np.eye(len(mu_0)))
noise_prior = pints.UniformLogPrior([lower_bounds[-1]],
[upper_bounds[-1]])
log_prior = pints.ComposedLogPrior(param_prior, noise_prior)
# Create a posterior log-likelihood (log(likelihood * prior))
log_posterior = pints.LogPosterior(log_likelihood, log_prior)
log_posteriors.append(log_posterior)
score = pints.ProbabilityBasedError(log_posterior)
if synthetic:
found_parameters = list(true_parameters) + [noise]
else:
found_parameters, found_value = pints.optimise(score,
x0,
sigma0,
boundaries,
method=pints.CMAES)
self._offset -= self._nt * np.log(sigma)
self._multip = -1 / (2.0 * sigma**2)
def __call__(self, x):
error = self._values - self._problem.evaluate(x)
return self.temperature * np.sum(self._offset + self._multip *
np.sum(error**2, axis=0))
# In[ ]:
sigma_noise = 1.
log_prior_a = pints.NormalLogPrior(2., 1.)
log_prior_b = pints.NormalLogPrior(3., 1.)
log_prior = pints.ComposedLogPrior(log_prior_a, log_prior_b)
# In[ ]:
import mcmcsampling
from joblib import Parallel, delayed
import multiprocessing
niter = 10000
def mcmc_runner(temps):
nchains = 1
#print('temperature', temps)
tempered_log_likelihood = tiLogLikelihood(problem, sigma_noise, temps)
tempered_log_posterior = pints.LogPosterior(tempered_log_likelihood,
