def test_crossover_file_loading(self):
"""Test that when a crossover file is loaded the crossover values are set to the file values and not adapted."""
self.param, self.like = multidmodel()
old_crossovervals = np.array([.45, .20, .35])
np.save('testing_crossoverval_load_DREAM.npy', old_crossovervals)
model = Model(self.like, self.param)
dream = Dream(model=model,
crossover_file='testing_crossoverval_load_DREAM.npy',
save_history=True,
model_name='testing_crossover_load')
self.assertTrue(
np.array_equal(dream.CR_probabilities, old_crossovervals))
sampled_vals, logps = run_dream(
self.param,
self.like,
niterations=100,
nchains=3,
crossover_file='testing_crossoverval_load_DREAM.npy',
model_name='testing_crossover_load',
save_history=True,
verbose=False)
crossover_vals_after_sampling = np.load(
'testing_crossover_load_DREAM_chain_adapted_crossoverprob.npy')
self.assertIs(
np.array_equal(crossover_vals_after_sampling, old_crossovervals),
True)
remove('testing_crossover_load_DREAM_chain_adapted_crossoverprob.npy')
remove('testing_crossover_load_DREAM_chain_adapted_gammalevelprob.npy')
remove('testing_crossoverval_load_DREAM.npy')
remove('testing_crossover_load_DREAM_chain_history.npy')
def test_paralleltempering_sampledreamfxn(self):
"""test that the parallel tempering DREAM sampling function returns values of the expected shape."""
self.params, self.like = multidmodel()
model = Model(self.like, self.params)
dream = Dream(model=model, verbose=False, save_history=False)
#The pool will be used within the fxn and, also, we need to initialize the shared variables.
pool = _setup_mp_dream_pool(nchains=3,
niterations=10,
step_instance=dream)
pool._initializer(*pool._initargs)
start = np.array([-100, 5, 8, .001])
sampled_params, logps = _sample_dream_pt(nchains=3,
niterations=10,
step_instance=dream,
start=start,
pool=pool,
verbose=False)
self.assertEqual(len(sampled_params), 3)
self.assertEqual(len(sampled_params[0]), 20)
self.assertEqual(len(sampled_params[0][0]), 4)
self.assertEqual(len(logps), 3)
self.assertEqual(len(logps[0]), 20)
self.assertEqual(len(logps[0][0]), 1)
def test_history_recording_multidim_model(self):
"""Test that history in memory matches with that recorded for test multi-dimensional model."""
self.param, self.like = multidmodel()
model = Model(self.like, self.param)
dream = Dream(model=model, model_name='test_history_recording')
history_arr = mp.Array('d', [0] * 4 * dream.total_var_dimension * 3)
n = mp.Value('i', 0)
nchains = mp.Value('i', 3)
pydream.Dream_shared_vars.history = history_arr
pydream.Dream_shared_vars.count = n
pydream.Dream_shared_vars.nchains = nchains
test_history = np.array([[[1, 2, 3, 4], [3, 4, 5, 6], [5, 6, 7, 8]],
[[7, 8, 9, 10], [9, 12, 18, 20],
[11, 14, 18, 8]],
[[13, 14, 18, 4], [15, 17, 11, 8],
[17, 28, 50, 4]],
[[19, 21, 1, 18], [21, 19, 19, 11],
[23, 4, 3, 2]]])
for chainpoint in test_history:
for point in chainpoint:
dream.record_history(nseedchains=0,
ndimensions=dream.total_var_dimension,
q_new=point,
len_history=len(history_arr))
history_arr_np = np.frombuffer(
pydream.Dream_shared_vars.history.get_obj())
history_arr_np_reshaped = history_arr_np.reshape(
np.shape(test_history))
self.assertIs(np.array_equal(history_arr_np_reshaped, test_history),
True)
remove('test_history_recording_DREAM_chain_history.npy')
remove('test_history_recording_DREAM_chain_adapted_crossoverprob.npy')
remove('test_history_recording_DREAM_chain_adapted_gammalevelprob.npy')
def test_proposal_generation_snooker(self):
"""Test that proposal generation with a snooker update returns values of the expected shape."""
self.param, self.like = multidmodel()
model = Model(self.like, self.param)
step = Dream(model=model)
history_arr = mp.Array('d', list(range(120)))
n = mp.Value('i', 0)
pydream.Dream_shared_vars.history = history_arr
pydream.Dream_shared_vars.count = n
step.nseedchains = 20
q0 = np.array([2, 3, 4, 5])
proposed_pt, snooker_logp, z = step.generate_proposal_points(
n_proposed_pts=1,
q0=q0,
CR=1,
DEpairs=1,
gamma_level=1,
snooker=True)
self.assertEqual(len(proposed_pt), step.total_var_dimension)
proposed_pts, snooker_logp, z = step.generate_proposal_points(
n_proposed_pts=5,
q0=q0,
CR=1,
DEpairs=1,
gamma_level=1,
snooker=True)
self.assertEqual(len(proposed_pts), 5)
def test_multitry_logp_eval(self):
"""Test that evaluation of multiple trials either in parallel or not matches with known logp values."""
self.param, self.like = multidmodel()
model = Model(self.like, self.param)
step = Dream(model=model)
logp = step.logp
proposed_pts = [[1, 2, 3, 4], [7, 8, 9, 10], [13, 14, 15, 16]]
logpriors, loglikes = step.mt_evaluate_logps(parallel=False,
multitry=3,
proposed_pts=proposed_pts,
pfunc=logp)
correct_loglikes = []
correct_logpriors = []
for pt in proposed_pts:
prior, like = logp(np.array(pt))
correct_logpriors.append(prior)
correct_loglikes.append(like)
self.assertEqual(
np.array_equal(logpriors, np.array(correct_logpriors)), True)
self.assertEqual(np.array_equal(loglikes, np.array(correct_loglikes)),
True)
logpriors, loglikes = step.mt_evaluate_logps(parallel=True,
multitry=3,
proposed_pts=proposed_pts,
pfunc=logp)
self.assertEqual(
np.array_equal(logpriors, np.array(correct_logpriors)), True)
self.assertEqual(np.array_equal(loglikes, np.array(correct_loglikes)),
True)
def test_proposal_generation_nosnooker_CR66(self):
"""Test proposal generation without a snooker update with a single or multiple proposed points and a crossover value of 2/3 gives 2/3 of all dimensions changed on average as expected."""
self.param, self.like = multidmodel()
model = Model(self.like, self.param)
step = Dream(model=model)
history_arr = mp.Array('d', list(range(120)))
n = mp.Value('i', 0)
pydream.Dream_shared_vars.history = history_arr
pydream.Dream_shared_vars.count = n
step.nseedchains = 20
q0 = np.array([2, 3, 4, 5])
dims_kept = 0
for iteration in range(100000):
proposed_pt = step.generate_proposal_points(n_proposed_pts=1, q0=q0, CR=.66, DEpairs=1, gamma_level=1, snooker=False)
if iteration == 1:
self.assertEqual(len(proposed_pt), 1)
dims_change_vec = np.squeeze(q0 == proposed_pt)
for dim in dims_change_vec:
if dim:
dims_kept += 1
frac_kept = dims_kept/(step.total_var_dimension*100000.0)
self.assertAlmostEqual(frac_kept, 1-.66, places=1)
dims_kept = 0
for iteration in range(10000):
proposed_pts = step.generate_proposal_points(n_proposed_pts=5, q0=q0, CR=.66, DEpairs=1, gamma_level=1, snooker=False)
if iteration == 1:
self.assertEqual(len(proposed_pts), 5)
for pt in proposed_pts:
dims_change_vec = (q0 == pt)
for dim in dims_change_vec:
if dim:
dims_kept += 1
frac_kept = dims_kept/(step.total_var_dimension*10000.0*5)
self.assertAlmostEqual(frac_kept, 1-.66, places=1)
def test_chain_sampling_multidim_model(self):
"""Test that sampling from DREAM history for multi-dimensional model when the history is known matches with expected possible samples."""
self.params, self.like = multidmodel()
model = Model(likelihood=self.like, sampled_parameters=self.params)
dream = Dream(model=model)
history_arr = mp.Array('d', [0] * 2 * dream.total_var_dimension)
n = mp.Value('i', 0)
pydream.Dream_shared_vars.history = history_arr
pydream.Dream_shared_vars.count = n
chains_added_to_history = []
for i in range(2):
start = i * dream.total_var_dimension
end = start + dream.total_var_dimension
chain = dream.draw_from_prior(model.sampled_parameters)
pydream.Dream_shared_vars.history[start:end] = chain
chains_added_to_history.append(chain)
sampled_chains = dream.sample_from_history(
nseedchains=2, DEpairs=1, ndimensions=dream.total_var_dimension)
sampled_chains = np.array(sampled_chains)
chains_added_to_history = np.array(chains_added_to_history)
self.assertIs(
np.array_equal(
chains_added_to_history[chains_added_to_history[:,
0].argsort()],
sampled_chains[sampled_chains[:, 0].argsort()]), True)
def test_prior_draw(self):
"""Test random draw from prior for normally distributed priors in test models."""
self.param, self.like = onedmodel()
model = Model(likelihood=self.like, sampled_parameters=self.param)
self.assertEqual(len(Dream(model=model).draw_from_prior(model.sampled_parameters)), 1)
self.param, self.like = multidmodel()
model = Model(likelihood=self.like, sampled_parameters=self.param)
self.assertEqual(len(Dream(model=model).draw_from_prior(model.sampled_parameters)), 4)
def test_crossover_prob_estimation(self):
"""Test that crossover probabilities are updated as expected when changing or not changing parameter locations and giving points that give a greater jump distance."""
self.param, self.like = multidmodel()
model = Model(self.like, self.param)
dream = Dream(model=model, save_history=False)
starting_crossover = dream.CR_probabilities
crossover_probabilities = mp.Array('d', starting_crossover)
n = mp.Value('i', 0)
nCR = dream.nCR
CR_vals = dream.CR_values
ncrossover_updates = mp.Array('d', [0] * nCR)
current_position_arr = mp.Array(
'd', [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4])
dream.nchains = 5
delta_m = mp.Array('d', [0] * nCR)
dream.chain_n = 0
pydream.Dream_shared_vars.cross_probs = crossover_probabilities
pydream.Dream_shared_vars.count = n
pydream.Dream_shared_vars.ncr_updates = ncrossover_updates
pydream.Dream_shared_vars.current_positions = current_position_arr
pydream.Dream_shared_vars.delta_m = delta_m
q0 = np.array([1, 2, 3, 4])
q_new = np.array([1, 2, 3, 4])
new_cr_probs = dream.estimate_crossover_probabilities(
dream.total_var_dimension, q0, q_new, CR_vals[0])
self.assertEqual(np.array_equal(new_cr_probs, starting_crossover),
True)
q_new = np.array([1.2, 2.2, 3.3, 4.4])
new_cr_probs = dream.estimate_crossover_probabilities(
dream.total_var_dimension, q0, q_new, CR_vals[0])
self.assertEqual(np.array_equal(new_cr_probs, starting_crossover),
True)
q_new = np.array([2, 3, 4, 5])
new_cr_probs = dream.estimate_crossover_probabilities(
dream.total_var_dimension, q0, q_new, CR_vals[1])
self.assertEqual(np.array_equal(new_cr_probs, starting_crossover),
True)
q_new = np.array([11, -15, 20, 9])
new_cr_probs = dream.estimate_crossover_probabilities(
dream.total_var_dimension, q0, q_new, CR_vals[2])
self.assertEqual(np.array_equal(new_cr_probs, starting_crossover),
False)
self.assertGreater(new_cr_probs[2], starting_crossover[2])
self.assertAlmostEqual(np.sum(new_cr_probs), 1.0, places=1)
old_cr_probs = new_cr_probs
for i, q_new in zip(list(range(5)), [
np.array([15]),
np.array([17]),
np.array([19]),
np.array([21]),
np.array([23])
]):
new_cr_probs = dream.estimate_crossover_probabilities(
dream.total_var_dimension, q0, q_new, CR_vals[1])
self.assertEqual(np.array_equal(new_cr_probs, old_cr_probs), False)
def test_total_var_dimension_init(self):
"""Test that DREAM correctly identifies the total number of dimensions in all sampled parameters for a few test cases."""
self.param, self.like = onedmodel()
model = Model(likelihood=self.like, sampled_parameters=self.param)
step = Dream(model=model, variables=self.param)
self.assertEqual(step.total_var_dimension, 1)
self.param, self.like = multidmodel()
model = Model(likelihood=self.like, sampled_parameters=self.param)
step = Dream(model=model, variables=self.param)
self.assertEqual(step.total_var_dimension, 4)
def test_multitry_proposal_selection(self):
"""Test that multiple trial proposal selection matches expectated choice with test logp data."""
self.param, self.like = multidmodel()
model = Model(self.like, self.param)
step = Dream(model=model)
logpriors = np.array([0, 0])
loglikes = np.array([1000, 500])
proposed_pts = [[1, 2, 3, 4], [7, 8, 9, 10]]
for iteration in range(3):
q_proposal, q_logp, noT_logp, noT_loglike, q_prior= step.mt_choose_proposal_pt(logpriors, loglikes, proposed_pts, T=1)
self.assertEqual(np.array_equal(q_proposal, proposed_pts[0]), True)
def test_history_saving_to_disc_sanitycheck(self):
"""Test that history when saved to disc and reloaded matches."""
self.param, self.like = multidmodel()
model = Model(self.like, self.param)
step = Dream(model=model)
history = np.array([[5, 8, 10, 12], [13, 18, 20, 21], [1, .5, 9, 1e9]])
step.save_history_to_disc(history, 'testing_history_save_')
history_saved = np.load('testing_history_save_DREAM_chain_history.npy')
self.assertIs(np.array_equal(history, history_saved), True)
remove('testing_history_save_DREAM_chain_history.npy')
remove('testing_history_save_DREAM_chain_adapted_crossoverprob.npy')
remove('testing_history_save_DREAM_chain_adapted_gammalevelprob.npy')
def test_mp_paralleltempering_sampledreamfxn(self):
"""Test individual chain sampling function for parallel tempering returns an object of the correct type and with a better logp."""
self.params, self.like = multidmodel()
model = Model(self.like, self.params)
dream = Dream(model=model, verbose=False, save_history=False)
# Even though the pool won't be used, we need to initialize the shared variables.
pool = _setup_mp_dream_pool(nchains=3, niterations=10, step_instance=dream)
pool._initializer(*pool._initargs)
start = np.array([-.33, 10, 0, 99])
T = .33
last_loglike = -300
last_logprior = -100
args = [dream, start, T, last_loglike, last_logprior]
qnew, logprior_new, loglike_new, dream_instance = _sample_dream_pt_chain(args)
self.assertTrue(isinstance(qnew, np.ndarray))
self.assertTrue((logprior_new + loglike_new) >= -400)
def test_history_correct_after_sampling_multidim_model(self):
"""Test that the history saved matches with the returned sampled parameter values for a multi-dimensional test model."""
self.param, self.like = multidmodel()
model = Model(self.like, self.param)
step = Dream(model=model, save_history=True, history_thin=1, model_name='test_history_correct', adapt_crossover=False)
sampled_params, logps = run_dream(self.param, self.like, niterations=10, nchains=5, save_history=True, history_thin=1, model_name='test_history_correct', adapt_crossover=False, verbose=False)
history = np.load('test_history_correct_DREAM_chain_history.npy')
self.assertEqual(len(history), step.total_var_dimension*((10*5/step.history_thin)+step.nseedchains))
history_no_seedchains = history[(step.total_var_dimension*step.nseedchains)::]
sorted_history = np.sort(history_no_seedchains)
sorted_sampled_params = np.sort(np.array(sampled_params).flatten())
for sampled_param, history_param in zip(sorted_history, sorted_sampled_params):
self.assertEqual(sampled_param, history_param)
remove('test_history_correct_DREAM_chain_history.npy')
remove('test_history_correct_DREAM_chain_adapted_crossoverprob.npy')
remove('test_history_correct_DREAM_chain_adapted_gammalevelprob.npy')
def test_mp_sampledreamfxn(self):
"""Test the multiprocessing DREAM sample function returns data of the correct shape independently of the run_dream wrapper."""
self.params, self.like = multidmodel()
model = Model(self.like, self.params)
dream = Dream(model=model, verbose=False, save_history=False)
#Even though the pool won't be used, we need to initialize the shared variables.
pool = _setup_mp_dream_pool(nchains=3, niterations=10, step_instance=dream)
pool._initializer(*pool._initargs)
iterations = 10
start = np.array([-7, 8, 1.2, 0])
verbose = False
nverbose = 10
args = [dream, iterations, start, verbose, nverbose]
sampled_params, logps = _sample_dream(args)
self.assertEqual(len(sampled_params), 10)
self.assertEqual(len(sampled_params[0]), 4)
self.assertEqual(len(logps), 10)
self.assertEqual(len(logps[0]), 1)
