def test_generator_inout(self):
# mock measures
arr = np.random.rand(1, 10)
measuredict = Measurements()
measuredict.append(('test', 'nan', '10', 'nan'), arr, True)
# mock field
mock_par = {'a': 2., 'b': 0.2}
# ensemble num and random seed injected here
np.random.seed(mpirank) # assign different seed
ensemble_seeds = np.random.randint(
1, 10,
5) # numpy random gives the same sequence by default on all nodes
mock_field = TestField(mock_par, 5, ensemble_seeds)
# simulator
simer = LiSimulator(measuredict)
# generating observable ensemble
simdict = simer([mock_field]) # automatically append from all nodes
self.assertEqual(type(simdict), Simulations)
self.assertEqual(len(simdict.keys()), 1)
self.assertEqual(simdict[('test', 'nan', '10', 'nan')].shape,
(5 * mpisize, 10))
# simulator
simer = BiSimulator(measuredict)
# generating observable ensemble
simdict = simer([mock_field]) # automatically append from all nodes
self.assertEqual(type(simdict), Simulations)
self.assertEqual(len(simdict.keys()), 1)
self.assertEqual(simdict[('test', 'nan', '10', 'nan')].shape,
(5 * mpisize, 10))
def test_init(self):
arr = np.random.rand(1, 3)
measuredict = Measurements()
measuredict.append(('test', 'nan', '3', 'nan'), arr, True)
simer = LiSimulator(measuredict)
self.assertEqual(len(simer.output_checklist), 1)
self.assertEqual(simer.output_checklist,
(('test', 'nan', '3', 'nan'), ))
simer = BiSimulator(measuredict)
self.assertEqual(len(simer.output_checklist), 1)
self.assertEqual(simer.output_checklist,
(('test', 'nan', '3', 'nan'), ))
def test_li(self):
# mock measures
arr = np.random.rand(1, 3)
measuredict = Measurements()
measuredict.append(('test', 'nan', '3', 'nan'), arr, True)
# simulator
simer = LiSimulator(measuredict)
# regular field check
mock_par = {'a': 2, 'b': 0}
field_list = [TestField(mock_par, 1, None)]
obs_arr = simer.obs_generator(field_list, 1, 20)
# calc by hand
x = np.linspace(0., 2. * np.pi, 20)
baseline = 2. * np.cos(x)
self.assertListEqual(list(obs_arr[0]), list(baseline))
# mock parameters, take short cut without fields
mock_par = {'a': 2., 'b': 0.2}
field_list = [TestField(mock_par, 2, [23] * 2)]
obs_arr = simer.obs_generator(field_list, 2, 20)
self.assertEqual(obs_arr.shape, (2, 20))
# test same random seed
obs_arr_re = simer.obs_generator(field_list, 2, 20)
for i in range(obs_arr.shape[0]):
self.assertListEqual(list(obs_arr[i]), list(obs_arr_re[i]))
def testfield():
"""
:return:
log.basicConfig(filename='imagine.log', level=log.INFO)
"""
"""
# step 0, set 'a' and 'b', 'mea_std'
TestField in LiSimulator is modeled as
field = gaussian_random(mean=a,std=b)_x * cos(x)
where x in (0,2pi)
for generating mock data we need
true values of a and b: true_a, true_b, mea_seed
measurement uncertainty: mea_std
measurement points, positioned in (0,2pi) evenly, due to TestField modelling
"""
true_a = 3.
true_b = 6.
mea_std = 0.1 # std of gaussian measurement error
mea_seed = 233
mea_points = 10 # data points in measurements
truths = [true_a, true_b] # will be used in visualizing posterior
"""
# step 1, prepare mock data
"""
"""
# 1.1, generate measurements
mea_field = signal_field + noise_field
"""
x = np.linspace(0, 2. * np.pi, mea_points)
np.random.seed(mea_seed) # seed for signal field
signal_field = np.multiply(
np.cos(x), np.random.normal(loc=true_a, scale=true_b, size=mea_points))
mea_field = np.vstack([
signal_field + np.random.normal(loc=0., scale=mea_std, size=mea_points)
])
"""
# 1.2, generate covariances
"""
# pre-defined according to measurement error
mea_cov = (mea_std**2) * np.eye(mea_points)
"""
# 1.3 assemble in imagine convention
"""
mock_data = Measurements() # create empty Measrurements object
mock_cov = Covariances() # create empty Covariance object
# pick up a measurement
mock_data.append(('test', 'nan', str(mea_points), 'nan'), mea_field, True)
mock_cov.append(('test', 'nan', str(mea_points), 'nan'), mea_cov, True)
"""
# 1.4, visualize mock data
"""
#if mpirank == 0:
#matplotlib.pyplot.plot(x, mock_data[('test', 'nan', str(mea_points), 'nan')].to_global_data()[0])
#matplotlib.pyplot.savefig('testfield_mock.pdf')
"""
# step 2, prepare pipeline and execute analysis
"""
"""
# 2.1, ensemble likelihood
"""
likelihood = EnsembleLikelihood(
mock_data, mock_cov) # initialize likelihood with measured info
"""
# 2.2, field factory list
"""
factory = TestFieldFactory(
active_parameters=('a', 'b')) # factory with single active parameter
factory.parameter_ranges = {
'a': (0, 10),
'b': (0, 10)
} # adjust parameter range for Bayesian analysis
factory_list = [factory] # likelihood requires a list/tuple of factories
"""
# 2.3, flat prior
"""
prior = FlatPrior()
"""
# 2.4, simulator
"""
simer = LiSimulator(mock_data)
"""
# 2.5, pipeline
"""
ensemble_size = 10
pipe = MultinestPipeline(simer, factory_list, likelihood, prior,
ensemble_size)
pipe.random_type = 'free'
pipe.sampling_controllers = {
'n_iter_before_update': 1,
'n_live_points': 400,
'verbose': True,
'resume': False
}
results = pipe() # run with pymultinest
"""
# step 3, visualize (with corner package)
"""
if mpirank == 0:
samples = results['samples']
for i in range(len(
pipe.active_parameters)): # convert variables into parameters
low, high = pipe.active_ranges[pipe.active_parameters[i]]
for j in range(samples.shape[0]):
samples[j, i] = unity_mapper(samples[j, i], low, high)
# corner plot
corner.corner(samples[:, :len(pipe.active_parameters)],
range=[0.99] * len(pipe.active_parameters),
quantiles=[0.02, 0.5, 0.98],
labels=pipe.active_parameters,
show_titles=True,
title_kwargs={"fontsize": 15},
color='steelblue',
truths=truths,
truth_color='firebrick',
plot_contours=True,
hist_kwargs={'linewidth': 2},
label_kwargs={'fontsize': 15})
matplotlib.pyplot.savefig('testfield_posterior.pdf')
def testfield(measure_size, simulation_size, make_plots=True, debug=False):
if debug:
log.basicConfig(filename='imagine_li_dynesty.log', level=log.DEBUG)
else:
log.basicConfig(filename='imagine_li_dynesty.log')
"""
:return:
log.basicConfig(filename='imagine.log', level=log.INFO)
"""
"""
# step 0, set 'a' and 'b', 'mea_std'
TestField in LiSimulator is modeled as
field = gaussian_random(mean=a,std=b)_x * cos(x)
where x in (0,2pi)
for generating mock data we need
true values of a and b: true_a, true_b, mea_seed
measurement uncertainty: mea_std
measurement points, positioned in (0,2pi) evenly, due to TestField modelling
"""
true_a = 3.
true_b = 6.
mea_std = 0.1 # std of gaussian measurement error
mea_seed = 233
truths = [true_a, true_b] # will be used in visualizing posterior
"""
# step 1, prepare mock data
"""
"""
# 1.1, generate measurements
mea_field = signal_field + noise_field
"""
x = np.linspace(0, 2. * np.pi, measure_size) # data points in measurements
np.random.seed(mea_seed) # seed for signal field
signal_field = np.multiply(
np.cos(x), np.random.normal(loc=true_a,
scale=true_b,
size=measure_size))
mea_field = np.vstack([
signal_field +
np.random.normal(loc=0., scale=mea_std, size=measure_size)
])
"""
# 1.2, generate covariances
what's the difference between pre-define dan re-estimated?
"""
# re-estimate according to measurement error
mea_repeat = np.zeros((simulation_size, measure_size))
for i in range(simulation_size): # times of repeated measurements
mea_repeat[i, :] = signal_field + np.random.normal(
loc=0., scale=mea_std, size=measure_size)
mea_cov = oas_mcov(mea_repeat)[1]
print(mpirank, 're-estimated: \n', mea_cov, 'slogdet',
mpi_slogdet(mea_cov))
# pre-defined according to measurement error
mea_cov = (mea_std**2) * mpi_eye(measure_size)
print(mpirank, 'pre-defined: \n', mea_cov, 'slogdet', mpi_slogdet(mea_cov))
"""
# 1.3 assemble in imagine convention
"""
mock_data = Measurements() # create empty Measrurements object
mock_cov = Covariances() # create empty Covariance object
# pick up a measurement
mock_data.append(('test', 'nan', str(measure_size), 'nan'), mea_field,
True)
mock_cov.append(('test', 'nan', str(measure_size), 'nan'), mea_cov, True)
"""
# 1.4, visualize mock data
"""
if mpirank == 0 and make_plots:
plt.plot(x,
mock_data[('test', 'nan', str(measure_size), 'nan')].data[0])
plt.savefig('testfield_mock_li.pdf')
"""
# step 2, prepare pipeline and execute analysis
"""
"""
# 2.1, ensemble likelihood
"""
likelihood = EnsembleLikelihood(
mock_data, mock_cov) # initialize likelihood with measured info
"""
# 2.2, field factory list
"""
factory = TestFieldFactory(
active_parameters=('a', 'b')) # factory with single active parameter
factory.parameter_ranges = {
'a': (0, 10),
'b': (0, 10)
} # adjust parameter range for Bayesian analysis
factory_list = [factory] # likelihood requires a list/tuple of factories
"""
# 2.3, flat prior
"""
prior = FlatPrior()
"""
# 2.4, simulator
"""
simer = LiSimulator(mock_data)
"""
# 2.5, pipeline
"""
pipe = DynestyPipeline(simer, factory_list, likelihood, prior,
simulation_size)
pipe.random_type = 'controllable' # 'fixed' random_type doesnt work for Dynesty pipeline, yet
pipe.seed_tracer = int(23)
pipe.sampling_controllers = {'nlive': 400}
tmr = Timer()
tmr.tick('test')
results = pipe()
tmr.tock('test')
if mpirank == 0:
print('\n elapse time ' + str(tmr.record['test']) + '\n')
"""
# step 3, visualize (with corner package)
"""
if mpirank == 0 and make_plots:
samples = results['samples']
for i in range(len(
pipe.active_parameters)): # convert variables into parameters
low, high = pipe.active_ranges[pipe.active_parameters[i]]
for j in range(samples.shape[0]):
samples[j, i] = unity_mapper(samples[j, i], low, high)
# corner plot
corner.corner(samples[:, :len(pipe.active_parameters)],
range=[0.99] * len(pipe.active_parameters),
quantiles=[0.02, 0.5, 0.98],
labels=pipe.active_parameters,
show_titles=True,
title_kwargs={"fontsize": 15},
color='steelblue',
truths=truths,
truth_color='firebrick',
plot_contours=True,
hist_kwargs={'linewidth': 2},
label_kwargs={'fontsize': 20})
plt.savefig('testfield_posterior_li_dynesty.pdf')
def test_multinest(self):
# mock measures
arr = np.random.rand(1, 3)
measuredict = Measurements()
measuredict.append(('test', 'nan', '3', 'nan'), arr, True)
# simulator
simer = LiSimulator(measuredict)
# mock factory list
tf = TestFieldFactory(active_parameters=tuple('a'))
flist = (tf, )
# mock likelihood
lh = EnsembleLikelihood(measuredict)
# mock prior
pr = FlatPrior()
# pipeline
pipe = MultinestPipeline(simer, flist, lh, pr, 5)
self.assertEqual(pipe.active_parameters, ('test_a', ))
self.assertEqual(pipe.factory_list, (tf, ))
self.assertEqual(pipe.simulator, simer)
self.assertEqual(pipe.likelihood, lh)
self.assertEqual(pipe.prior, pr)
self.assertEqual(pipe.ensemble_size, 5)
self.assertEqual(pipe.sampling_controllers, {})
pipe.sampling_controllers = {'verbose': False}
self.assertEqual(pipe.sampling_controllers, {'verbose': False})
self.assertEqual(pipe.sample_callback, False)
pipe.sample_callback = True
self.assertEqual(pipe.sample_callback, True)
self.assertEqual(pipe.likelihood_rescaler, 1.)
pipe.likelihood_rescaler = 0.5
self.assertEqual(pipe.likelihood_rescaler, 0.5)
self.assertEqual(pipe.check_threshold, False)
pipe.check_threshold = True
self.assertEqual(pipe.check_threshold, True)
self.assertEqual(pipe.likelihood_threshold, 0.)
pipe.likelihood_threshold = -0.2
self.assertEqual(pipe.likelihood_threshold, -0.2)
self.assertEqual(pipe._ensemble_seeds, None)
self.assertEqual(pipe.seed_tracer, int(0))
self.assertEqual(pipe.random_type, 'free')
# test free random seed, full randomness
pipe._randomness()
s1 = pipe._ensemble_seeds
self.assertTrue(s1 is None)
# test controllable random seed, with top level seed controllable
pipe.random_type = 'controllable'
pipe.seed_tracer = int(3) # controlling seed at top level
pipe._randomness(
) # core func in assigning ensemble seeds, before calling simulator
s1 = pipe._ensemble_seeds
pipe._randomness() # 2nd call of sampeler
s2 = pipe._ensemble_seeds
pipe = MultinestPipeline(simer, flist, lh, pr, 5) # init a new sampler
pipe.random_type = 'controllable'
pipe.seed_tracer = int(3) # repeat the controlling seed
pipe._randomness()
s1re = pipe._ensemble_seeds
pipe._randomness()
s2re = pipe._ensemble_seeds
self.assertListEqual(list(s1), list(s1re)) # should get the same seeds
self.assertListEqual(list(s2), list(s2re))
pipe = MultinestPipeline(simer, flist, lh, pr, 5)
pipe.random_type = 'controllable'
pipe.seed_tracer = int(4) # different controlling seed
pipe._randomness()
s1new = pipe._ensemble_seeds
for i in range(len(s1)):
self.assertNotEqual(s1[i], s1new[i]) # should get different seeds
# test fixed random seed
pipe.random_type = 'fixed'
pipe.seed_tracer = int(5)
pipe._randomness() # 1st time seed assignment
s1 = pipe._ensemble_seeds
pipe._randomness() # 2nd time seed assignment
s1re = pipe._ensemble_seeds
self.assertListEqual(list(s1), list(s1re)) # should get the same seeds