def test_history_correct_after_sampling_simple_model(self):
"""Test that the history saved matches with the returned sampled parameter values for a one-dimensional test model."""
self.param, self.like = onedmodel()
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_history_recording_simple_model(self):
"""Test that history in memory matches with that recorded for test one-dimensional model."""
self.param, self.like = onedmodel()
model = Model(self.like, self.param)
step = Dream(model=model, model_name='test_history_recording')
history_arr = mp.Array('d', [0] * 4 * step.total_var_dimension)
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], [3], [5], [7]])
for chainpoint in test_history:
for point in chainpoint:
step.record_history(nseedchains=0,
ndimensions=step.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_astep_onedmodel(self):
"""Test that a single step with a one-dimensional model returns values of the expected type and a move that is expected or not given the test logp."""
"""Test a single step with a one-dimensional model with a normal parameter."""
self.param, self.like = onedmodel()
model = Model(self.like, self.param)
dream = Dream(model=model, save_history=False, verbose=False)
#Even though we're calling the steps separately we need to call these functions
# to initialize the shared memory arrays that are called in the step fxn
pool = _setup_mp_dream_pool(nchains=3,
niterations=10,
step_instance=dream)
pool._initializer(*pool._initargs)
#Test initial step (when last logp and prior values aren't set)
q_new, last_prior, last_like = dream.astep(q0=np.array([-5]))
self.assertTrue(isinstance(q_new, np.ndarray))
self.assertTrue(isinstance(last_prior, numbers.Number))
self.assertTrue(isinstance(last_like, numbers.Number))
#Test later iteration after last logp and last prior have been set
q_new, last_prior, last_like = dream.astep(q0=np.array(8),
last_logprior=-300,
last_loglike=-500)
self.assertTrue(isinstance(q_new, np.ndarray))
self.assertTrue(isinstance(last_prior, numbers.Number))
self.assertTrue(isinstance(last_like, numbers.Number))
if np.any(q_new != np.array(8)):
self.assertTrue(last_prior + last_like >= -800)
else:
self.assertTrue(last_prior == -300)
self.assertTrue(last_like == -500)
def test_DEpair_selec(self):
"""Test that fraction for selected DEpair value is consistent with number of specified DEPair value."""
self.param, self.like = onedmodel()
single_DEpair = np.array([1])
multi_DEpair = np.array([1, 2, 3])
nDE1 = 0
nDE2 = 0
nDE3 = 0
model = Model(likelihood=self.like, sampled_parameters=self.param)
step = Dream(model=model, variables=self.param)
self.assertEqual(step.set_DEpair(single_DEpair), 1)
for iteration in range(10000):
choice = step.set_DEpair(multi_DEpair)
if choice == multi_DEpair[0]:
nDE1 += 1
elif choice == multi_DEpair[1]:
nDE2 += 1
else:
nDE3 += 1
emp_frac1 = nDE1 / 10000.0
emp_frac2 = nDE2 / 10000.0
emp_frac3 = nDE3 / 10000.0
self.assertAlmostEqual(emp_frac1, .3, places=1)
self.assertAlmostEqual(emp_frac2, .3, places=1)
self.assertAlmostEqual(emp_frac3, .3, places=1)
def test_chain_sampling_simple_model(self):
"""Test that sampling from DREAM history for one dimensional model when the history is known matches with expected possible samples."""
self.param, self.like = onedmodel()
model = Model(likelihood=self.like, sampled_parameters=self.param)
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(dream.variables)
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_gamma_snooker_choice(self):
"""Test that when a snooker move is made, gamma is set to a random value between 1.2 and 2.2."""
self.param, self.like = onedmodel()
model = Model(likelihood=self.like, sampled_parameters=self.param)
step = Dream(model=model)
self.assertGreaterEqual(step.set_gamma(DEpairs=1, snooker_choice=True, gamma_level_choice=1, d_prime=3), 1.2)
self.assertLess(step.set_gamma(DEpairs=1, snooker_choice=True, gamma_level_choice=1, d_prime=3), 2.2)
def test_history_file_loading(self):
"""Test that when a history file is provided it is loaded and appended to the new history."""
self.param, self.like = onedmodel()
model = Model(self.like, self.param)
step = Dream(model=model)
old_history = np.array([1, 3, 5, 7, 9, 11])
step.save_history_to_disc(old_history, 'testing_history_load_')
sampled_params, logps = run_dream(self.param, self.like, niterations=3, nchains=3, history_thin=1, history_file='testing_history_load_DREAM_chain_history.npy', save_history=True, model_name='test_history_loading', verbose=False)
new_history = np.load('test_history_loading_DREAM_chain_history.npy')
self.assertEqual(len(new_history), (len(old_history.flatten())+(3*step.total_var_dimension*3)))
new_history_seed = new_history[:len(old_history.flatten())]
new_history_seed_reshaped = new_history_seed.reshape(old_history.shape)
self.assertIs(np.array_equal(old_history, new_history_seed_reshaped), True)
added_history = new_history[len(old_history.flatten())::]
sorted_history = np.sort(added_history)
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('testing_history_load_DREAM_chain_history.npy')
remove('testing_history_load_DREAM_chain_adapted_crossoverprob.npy')
remove('testing_history_load_DREAM_chain_adapted_gammalevelprob.npy')
remove('test_history_loading_DREAM_chain_adapted_crossoverprob.npy')
remove('test_history_loading_DREAM_chain_adapted_gammalevelprob.npy')
remove('test_history_loading_DREAM_chain_history.npy')
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_gamma_array(self):
"""Test assigned value of gamma array matches for test data."""
true_gamma_array = np.array([[1.683, 1.19, .972, .841, .753]])
self.param, self.like = onedmodel()
model = Model(likelihood=self.like, sampled_parameters=self.param)
dream = Dream(model=model, DEpairs=5, p_gamma_unity=0)
for d_prime in range(1, dream.total_var_dimension+1):
for n_DEpair in range(1, 6):
self.assertAlmostEqual(true_gamma_array[d_prime-1][n_DEpair-1], dream.set_gamma(DEpairs=n_DEpair, snooker_choice=False, gamma_level_choice=1, d_prime=d_prime), places=3)
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_fail_with_one_chain(self):
"""Test that DREAM fails if run with only one chain."""
self.param, self.like = onedmodel()
assertRaisesRegex = self.assertRaisesRegexp if sys.version_info[
0] < 3 else self.assertRaisesRegex
assertRaisesRegex(Exception,
'Dream should be run with at least ',
run_dream,
self.param,
self.like,
nchains=1)
def test_snooker_fraction(self):
"""Test that the fraction of snooker moves corresponds to the snooker parameter."""
self.param, self.like = onedmodel()
n_snooker_choices = 0
model = Model(likelihood=self.like, sampled_parameters=self.param)
step = Dream(model=model)
fraction = step.snooker
for iteration in range(10000):
choice = step.set_snooker()
if choice == True:
n_snooker_choices += 1
emp_frac = n_snooker_choices / 10000.0
self.assertAlmostEqual(emp_frac, fraction, places=1)
def test_gamma_unityfraction(self):
"""Test that gamma value is set to 1 the fraction of times indicated by the p_gamma_unity DREAM parameter."""
self.param, self.like = onedmodel()
n_unity_choices = 0
model = Model(likelihood=self.like, sampled_parameters=self.param)
step = Dream(model=model)
fraction = step.p_gamma_unity
for iteration in range(10000):
choice = step.set_gamma(DEpairs=1, snooker_choice=False, gamma_level_choice=1, d_prime=step.total_var_dimension)
if choice == 1:
n_unity_choices += 1
emp_frac = n_unity_choices/10000.0
self.assertAlmostEqual(emp_frac, fraction, places=1)
def test_CR_fraction(self):
"""Test that the crossover values chosen match with the crossover probability values for test data."""
self.param, self.like = onedmodel()
nCR1 = 0
nCR2 = 0
nCR3 = 0
crossoverprobs = np.array([.10, .65, .25])
crossovervals = np.array([.33, .66, 1.0])
model = Model(likelihood=self.like, sampled_parameters=self.param)
step = Dream(model=model, variables=self.param)
for iteration in range(10000):
choice = step.set_CR(crossoverprobs, crossovervals)
if choice == crossovervals[0]:
nCR1 += 1
elif choice == crossovervals[1]:
nCR2 += 1
else:
nCR3 += 1
emp_frac1 = nCR1 / 10000.0
emp_frac2 = nCR2 / 10000.0
emp_frac3 = nCR3 / 10000.0
self.assertAlmostEqual(emp_frac1, crossoverprobs[0], places=1)
self.assertAlmostEqual(emp_frac2, crossoverprobs[1], places=1)
self.assertAlmostEqual(emp_frac3, crossoverprobs[2], places=1)
