def test_transform(self):
# Test optimisation with parameter transformation.
# Test with LogPDF
r = pints.toy.TwistedGaussianLogPDF(2, 0.01)
x0 = np.array([0, 1.01])
b = pints.RectangularBoundaries([-0.01, 0.95], [0.01, 1.05])
s = 0.01
t = pints.RectangularBoundariesTransformation(b)
opt = pints.OptimisationController(r, x0, s, b, t, method)
opt.set_log_to_screen(False)
opt.set_max_unchanged_iterations(None)
opt.set_max_iterations(10)
opt.run()
# Test with ErrorMeasure
r = pints.toy.ParabolicError()
x0 = [0.1, 0.1]
b = pints.RectangularBoundaries([-1, -1], [1, 1])
s = 0.1
t = pints.RectangularBoundariesTransformation(b)
pints.OptimisationController(r,
x0,
boundaries=b,
transform=t,
method=method)
opt = pints.OptimisationController(r, x0, s, b, t, method)
opt.set_log_to_screen(False)
opt.set_max_unchanged_iterations(None)
opt.set_max_iterations(10)
x, _ = opt.run()
# Test output are detransformed
self.assertEqual(x.shape, (2, ))
self.assertTrue(b.check(x))
def setUpClass(cls):
# Create Transformation class
lower1 = np.array([1])
upper1 = np.array([10])
lower2 = np.array([1, 2])
upper2 = np.array([10, 20])
# Test normal construction with lower and upper
cls.t1 = pints.RectangularBoundariesTransformation(lower1, upper1)
cls.t2 = pints.RectangularBoundariesTransformation(lower2, upper2)
# Test construction with rectangular boundaries object
b2 = pints.RectangularBoundaries(lower2, upper2)
cls.t2b = pints.RectangularBoundariesTransformation(b2)
cls.p = [1.5, 15.]
cls.x = [-2.8332133440562162, 0.9555114450274365]
cls.j = np.diag([0.4722222222222225, 3.6111111111111098])
cls.j_s1_diag = [0.4197530864197533, -1.6049382716049378]
cls.j_s1 = np.zeros((2, 2, 2))
for i in range(2):
cls.j_s1[i, i, i] = cls.j_s1_diag[i]
cls.log_j_det = 0.5337099175995788
cls.log_j_det_s1 = [0.8888888888888888, -0.4444444444444445]
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 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'))
