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)