def test_transformed_log_pdf(self):
# Test TransformedLogPDF class
t = pints.LogTransformation(2)
r = pints.toy.TwistedGaussianLogPDF(2, 0.01)
x = [0.05, 1.01]
tx = [-2.9957322735539909, 0.0099503308531681]
j = np.diag(x)
log_j_det = -2.9857819427008230
tr = t.convert_log_pdf(r)
# Test before and after transformed give the same result
self.assertAlmostEqual(tr(tx), r(x) + log_j_det)
self.assertEqual(tr.n_parameters(), r.n_parameters())
# Test evaluateS1()
rx, s1 = r.evaluateS1(x)
trx = rx + log_j_det
ts1 = np.matmul(s1, j) + np.ones(2)
trtx, trts1 = tr.evaluateS1(tx)
self.assertTrue(np.allclose(trtx, trx))
self.assertTrue(np.allclose(trts1, ts1))
# Test invalid transform
self.assertRaises(ValueError, pints.TransformedLogPDF, r,
pints.LogTransformation(3))
def setUpClass(cls):
# Create Transformation class
cls.t1 = pints.LogTransformation(1)
cls.t4 = pints.LogTransformation(4)
cls.p = [0.1, 1., 10., 999.]
cls.x = [-2.3025850929940455, 0., 2.3025850929940459,
6.9067547786485539]
cls.j = np.diag(cls.p)
cls.j_s1 = np.zeros((4, 4, 4))
for i in range(4):
cls.j_s1[i, i, i] = cls.p[i]
cls.log_j_det = np.sum(cls.x)
cls.log_j_det_s1 = np.ones(4)
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_transformed_boundaries(self):
# Test TransformedBoundaries class
t = pints.LogTransformation(2)
b = pints.RectangularBoundaries([0.01, 0.95], [0.05, 1.05])
tb = t.convert_boundaries(b)
xi = [0.02, 1.01]
txi = [-3.9120230054281460, 0.0099503308531681]
xo = [10., 50.]
txo = [2.3025850929940459, 3.9120230054281460]
tr = [1.6094379124341001, 0.1000834585569826]
# Test before and after transformed give the same result
self.assertEqual(tb.check(txi), b.check(xi))
self.assertEqual(tb.check(txo), b.check(xo))
self.assertEqual(tb.n_parameters(), b.n_parameters())
# Test transformed range
self.assertTrue(np.allclose(tb.range(), tr))
# Test invalid transform
self.assertRaises(ValueError, pints.TransformedBoundaries, b,
pints.LogTransformation(3))
def test_transformed_error_measure(self):
# Test TransformedErrorMeasure class
t = pints.LogTransformation(2)
r = pints.toy.ParabolicError()
x = [0.1, 0.1]
tx = [-2.3025850929940455, -2.3025850929940455]
j = np.diag(x)
tr = t.convert_error_measure(r)
# Test before and after transformed give the same result
self.assertAlmostEqual(tr(tx), r(x))
self.assertEqual(tr.n_parameters(), r.n_parameters())
# Test evaluateS1()
rx, s1 = r.evaluateS1(x)
ts1 = np.matmul(s1, j)
trtx, trts1 = tr.evaluateS1(tx)
self.assertTrue(np.allclose(trtx, rx))
self.assertTrue(np.allclose(trts1, ts1))
# Test invalid transform
self.assertRaises(ValueError, pints.TransformedErrorMeasure, r,
pints.LogTransformation(3))
def test_transformed_log_prior(self):
# Test TransformedLogPrior class
d = 2
t = pints.LogTransformation(2)
r = pints.UniformLogPrior([0.1, 0.1], [0.9, 0.9])
tr = t.convert_log_prior(r)
# Test sample
n = 1
x = tr.sample(n)
self.assertEqual(x.shape, (n, d))
self.assertTrue(np.all(x < 0.))
n = 1000
x = tr.sample(n)
self.assertEqual(x.shape, (n, d))
self.assertTrue(np.all(x < 0.))
def setUpClass(cls):
# Create Transformation class
cls.t1 = TestNonElementWiseIdentityTransformation(1)
lower2 = np.array([1, 2])
upper2 = np.array([10, 20])
cls.t2 = pints.RectangularBoundariesTransformation(lower2, upper2)
cls.t3 = pints.LogTransformation(1)
cls.t = pints.ComposedTransformation(cls.t1, cls.t2, cls.t3)
cls.p = [0.1, 1.5, 15., 999.]
cls.x = [0.1, -2.8332133440562162, 0.9555114450274365,
6.9067547786485539]
cls.j = np.diag([1., 0.4722222222222225, 3.6111111111111098, 999.])
cls.j_s1_diag = [0., 0.4197530864197533, -1.6049382716049378, 999.]
cls.j_s1 = np.zeros((4, 4, 4))
for i in range(4):
cls.j_s1[i, i, i] = cls.j_s1_diag[i]
cls.log_j_det = 7.4404646962481324
cls.log_j_det_s1 = [0., 0.8888888888888888, -0.4444444444444445, 1.]
def inference(model, values, times):
# Create an object with links to the model and time series
problem = pints.SingleOutputProblem(model, times, values)
# Create a log-likelihood function (adds an extra parameter!)
log_likelihood = pints.GaussianLogLikelihood(problem)
# Create a uniform prior over both the parameters and the new noise variable
lower_bounds = np.array([1e-3, 0.0, 0.4, 0.1, 1e-6, 8.0, 1e-4])
upper_bounds = np.array([10.0, 0.4, 0.6, 100.0, 100e-6, 10.0, 0.2])
log_prior = pints.UniformLogPrior(lower_bounds, upper_bounds)
# Create a posterior log-likelihood (log(likelihood * prior))
log_posterior = pints.LogPosterior(log_likelihood, log_prior)
# Choose starting points for 3 mcmc chains
# params = ['k0', 'E0', 'a', 'Ru', 'Cdl', 'freq', 'sigma']
start_parameters = np.array(
[0.0101, 0.214, 0.53, 8.0, 20.0e-6, 9.0152, 0.01])
transform = pints.ComposedTransformation(
pints.LogTransformation(1),
pints.RectangularBoundariesTransformation(lower_bounds[1:],
upper_bounds[1:]),
)
sigma0 = [0.1 * (h - l) for l, h in zip(lower_bounds, upper_bounds)]
boundaries = pints.RectangularBoundaries(lower_bounds, upper_bounds)
found_parameters, found_value = pints.optimise(log_posterior,
start_parameters,
sigma0,
boundaries,
transform=transform,
method=pints.CMAES)
xs = [
found_parameters * 1.001,
found_parameters * 1.002,
found_parameters * 1.003,
]
for x in xs:
x[5] = found_parameters[5]
print('start_parameters', start_parameters)
print('found_parameters', found_parameters)
print('lower_bounds', lower_bounds)
print('upper_bounds', upper_bounds)
# Create mcmc routine with four chains
mcmc = pints.MCMCController(log_posterior,
3,
xs,
method=pints.HaarioBardenetACMC,
transform=transform)
# Add stopping criterion
mcmc.set_max_iterations(10000)
# Run!
chains = mcmc.run()
# Save chains for plotting and analysis
pickle.dump((xs, pints.GaussianLogLikelihood, log_prior, chains,
'HaarioBardenetACMC'), open('results.pickle', 'wb'))
def create_pints_transform(self):
if False:
return pints.LogTransformation(n_parameters=1)
else:
return pints.IdentityTransformation(n_parameters=1)
def inference2(model_raw, model_old, model, values, times):
# Create an object with links to the model and time series
problem = pints.SingleOutputProblem(model_old, times, values)
# Create a log-likelihood function (adds an extra parameter!)
log_likelihood = pints.GaussianLogLikelihood(problem)
# Create a uniform prior over both the parameters and the new noise variable
e0_buffer = 0.1 * (model_raw.params['Ereverse'] - model_raw.params['Estart'])
lower_bounds = np.array([
0.0,
model_raw.params['Estart'] + e0_buffer,
0.0,
0.0,
0.4,
0.9* model_raw.params['omega'],
1e-4,
])
upper_bounds = np.array([
100 * model_raw.params['k0'],
model_raw.params['Ereverse'] - e0_buffer,
10 * model_raw.params['Cdl'],
10 * model_raw.params['Ru'],
0.6,
1.1* model_raw.params['omega'],
0.2,
])
log_prior = pints.UniformLogPrior(lower_bounds, upper_bounds)
# Create a posterior log-likelihood (log(likelihood * prior))
log_posterior = pints.LogPosterior(log_likelihood, log_prior)
# Choose starting points for 3 mcmc chains
param_names = ['k0', 'E0', 'Cdl', 'Ru', 'alpha', 'omega', 'sigma']
start_parameters = np.array([
model_raw.params['k0'],
model_raw.params['E0'],
model_raw.params['Cdl'],
model_raw.params['Ru'],
model_raw.params['alpha'],
model_raw.params['omega'],
0.01
])
sigma0 = [0.5 * (h - l) for l, h in zip(lower_bounds, upper_bounds)]
boundaries = pints.RectangularBoundaries(lower_bounds, upper_bounds)
#found_parameters, found_value = pints.optimise(
# log_posterior,
# start_parameters,
# sigma0,
# boundaries,
# method=pints.CMAES
# )
found_parameters = start_parameters
print('start_parameters', start_parameters)
print('found_parameters', found_parameters)
xs = [
found_parameters * 1.001,
found_parameters * 0.999,
found_parameters * 0.998,
]
for x in xs:
x[5] = found_parameters [5]
# adjust Ru to something reasonable
xs[0][3] = 1.001*5e-5
xs[1][3] = 1.00*5e-5
xs[2][3] = 0.999*5e-5
transform = pints.ComposedElementWiseTransformation(
pints.LogTransformation(1),
pints.RectangularBoundariesTransformation(
lower_bounds[1:], upper_bounds[1:]
),
)
# Create mcmc routine with four chains
mcmc = pints.MCMCController(log_posterior, 3, xs, method=pints.HaarioBardenetACMC,
transform=transform)
# Add stopping criterion
mcmc.set_max_iterations(10000)
# Run!
chains = mcmc.run()
# Save chains for plotting and analysis
pickle.dump((xs, pints.GaussianLogLikelihood, log_prior,
chains, 'HaarioACMC'), open('results2.pickle', 'wb'))
