def test_complex_compound_name(self): model = SimpleModel() parameter = prior.ComplexPrior(prior.Uniform(0, 1), prior.Uniform(2, 3)) model._convert_to_map(parameter, 'prefix') self.assertEqual(model._parameter_names[-2], 'prefix.real') self.assertEqual(model._parameter_names[-1], 'prefix.imag')
def test_map_composite_object(self): model = SimpleModel() parameter = [prior.ComplexPrior(0, 1), {'a': 2, 'b': [4, 5]}, 6] parameter_map = model._convert_to_map(parameter) expected = [[transformed_prior, [complex, [0, 1]]], [dict, [[['a', 2], ['b', [4, 5]]]]], 6] self.assertEqual(parameter_map, expected)
def test_map_prior(self): model = SimpleModel() parameter = prior.Uniform(0, 1) position = len(model._parameters) parameter_map = model._convert_to_map(parameter, 'new name') expected = '_parameter_{}'.format(position) self.assertEqual(parameter_map, expected)
def test_map_list(self): model = SimpleModel() parameter = [0, prior.Uniform(0, 1), prior.Uniform(2, 3)] position = len(model._parameters) parameter_map = model._convert_to_map(parameter) expected = [0, "_parameter_{}".format(position), "_parameter_{}".format(position + 1)] self.assertEqual(parameter_map, expected)
def test_map_dictionary(self): model = SimpleModel() parameter = {'a': 0, 'b': 1, 'c': prior.Uniform(0, 1)} position = len(model._parameters) parameter_map = model._convert_to_map(parameter) expected_placeholder = "_parameter_{}".format(position) expected = [dict, [[['a', 0], ['b', 1], ['c', expected_placeholder]]]] self.assertEqual(parameter_map, expected)
def test_map_complex(self): model = SimpleModel() parameter = prior.ComplexPrior(1, prior.Uniform(2, 3)) position = len(model._parameters) parameter_map = model._convert_to_map(parameter) placeholder = "_parameter_{}".format(position) expected = [transformed_prior, [complex, [1, placeholder]]] self.assertEqual(parameter_map, expected)
def test_xarray_compound_name(self): model = SimpleModel() parameter = xr.DataArray(np.zeros((3, 3)), coords=[[10, 20, 30], ['a', 'b', 'c']], dims=('tens', 'letters')).astype('object') parameter[-1, -1] = prior.Uniform(0, 1) model._convert_to_map(parameter, 'prefix') self.assertEqual(model._parameter_names[-1], 'prefix.30.c')
def test_model_sample_method_identical_to_strategy_method(self): model = SimpleModel() strategy = EmceeStrategy(nwalkers=6, nsamples=10, seed=123) data = np.array(.5) strategy_result = strategy.sample(model, data) strategy_result.time = None model_result = model.sample(data, strategy) model_result.time = None self.assertEqual(strategy_result, model_result)
def test_model_fit_method_identical_to_strategy_method(self): model = SimpleModel() strategy = NmpfitStrategy(seed=123) data = np.array(.5) strategy_result = strategy.fit(model, data) strategy_result.time = None model_result = model.fit(data, strategy) model_result.time = None self.assertEqual(strategy_result, model_result)
def test_map_hierarchical_transformed_prior(self): model = SimpleModel() inner = prior.TransformedPrior(np.sqrt, prior.Uniform(0, 2)) full = prior.TransformedPrior(np.maximum, [inner, prior.Uniform(0, 1)]) position = len(model._parameters) parameter_map = model._convert_to_map(full) placeholder = ['_parameter_{}'.format(position + i) for i in range(2)] submap = [transformed_prior, [np.sqrt, [placeholder[0]]]] expected = [transformed_prior, [np.maximum, [submap, placeholder[1]]]]
def test_map_transformed_prior(self): model = SimpleModel() transformed = prior.TransformedPrior(np.sqrt, prior.Uniform(0, 2), name='sqrt') position = len(model._parameters) parameter_map = model._convert_to_map(transformed) placeholder = "_parameter_{}".format(position) expected = [transformed_prior, [np.sqrt, [placeholder]]] self.assertEqual(parameter_map, expected)
def test_map_xarray(self): model = SimpleModel() parameter = xr.DataArray(np.zeros((3, 3)), coords=[[10, 20, 30], ['a', 'b', 'c']], dims=('tens', 'letters')) parameter_map = model._convert_to_map(parameter) expected_1D = [make_xarray, ['letters', ['a', 'b', 'c'], [0, 0, 0]]] expected = [make_xarray, ['tens', [10, 20, 30], [expected_1D, expected_1D, expected_1D]]] self.assertEqual(parameter_map, expected)
def test_fit_function_identical_to_strategy_method(self): model = SimpleModel() strategy = NmpfitStrategy(seed=123) strategy_result = strategy.fit(model, DATA) strategy_result.time = None model_result = fit(DATA, model, strategy=strategy) model_result.time = None self.assertEqual(strategy_result, model_result)
def test_sample_function_identical_to_strategy_method(self): model = SimpleModel() strategy = EmceeStrategy(nwalkers=6, nsamples=10, seed=123) strategy_result = strategy.sample(model, DATA) strategy_result.time = None model_result = sample(DATA, model, strategy) model_result.time = None self.assertEqual(strategy_result, model_result)
def test_default_sampling_strategy_is_emcee(self): # for speed, we monkey-patch emcee.default_nsamples # FIXME this is maybe not the best way to do this. put_back = EmceeStrategy._default_nsamples * 1 EmceeStrategy._default_nsamples = 1 result = sample(DATA, SimpleModel()) self.assertTrue(isinstance(result.strategy, EmceeStrategy)) # and put it back!! EmceeStrategy._default_nsamples = put_back self.assertNotEqual(EmceeStrategy._default_nsamples, 1)
def test_sample_emcee(self): data = np.array(.5) nwalkers = 10 ndim = 1 mod = SimpleModel(1) p0 = np.linspace(0, 1, nwalkers*ndim).reshape((nwalkers, ndim)) sampler = sample_emcee( mod, data, nwalkers, 500, p0, parallel=None, seed=40) try: chain = sampler.get_chain() lnprob = sampler.get_log_prob() except AttributeError: # emcee version < 3.0.0 chain = sampler.chain lnprob = sampler.lnprobability should_be_onehalf = chain[lnprob == lnprob.max()] assert_allclose(should_be_onehalf, .5, rtol=.001)
def test_fit_works_with_model(self): function_result = fit(DATA, SimpleModel()) function_result.time = None object_result = SimpleModel().fit(DATA) object_result.time = None self.assertEqual(function_result, object_result)
def test_sample_function_calls_model_sample(self): result = sample(DATA, SimpleModel()) self.assertTrue(isinstance(result, SamplingResult)) self.assertTrue(isinstance(result.strategy, EmceeStrategy)) self.assertTrue(hasattr(result, 'samples'))
def test_EmceeStrategy(self): data = np.array(.5) mod = SimpleModel(1) strat = EmceeStrategy(10, 15, None, None, seed=48) r = strat.sample(mod, data) assert_allclose(r._parameters, .5, rtol=.001)
def test_default_popsize(): npars = 2 mod = SimpleModel(npars) strat = CmaStrategy(seed=18, tols=tols, popsize=None) strat.fit(mod, data) assert_equal(strat.popsize, int(2 + npars + np.sqrt(npars)))
def test_CmaStrategy(): mod = SimpleModel() strat = CmaStrategy(seed=18, tols=tols, popsize=5) r = strat.fit(mod, data) assert_allclose(np.mean(r._parameters), .55, atol=.001)
def test_fit_takes_strategy_by_name(self): result = fit(DATA, SimpleModel(), strategy='cma') self.assertTrue(isinstance(result.strategy, CmaStrategy))
def test_list_compound_name(self): model = SimpleModel() parameter = [0, prior.Uniform(0, 1), prior.Uniform(2, 3)] model._convert_to_map(parameter, 'prefix') self.assertEqual(model._parameter_names[-2], 'prefix.1') self.assertEqual(model._parameter_names[-1], 'prefix.2')
def test_map_value(self): model = SimpleModel() parameter = 14 parameter_map = model._convert_to_map(parameter) expected = parameter self.assertEqual(parameter_map, expected)
def test_map_dictionary_ignores_none(self): model = SimpleModel() parameter = {'a': 0, 'b': 1, 'c': None} parameter_map = model._convert_to_map(parameter) expected = [dict, [[['a', 0], ['b', 1]]]] self.assertEqual(parameter_map, expected)
def test_fit_fails_with_sampling_strategy(self): self.assertRaises(ValueError, fit, DATA, SimpleModel(), strategy=EmceeStrategy)
def test_sample_fails_with_fitting_strategy(self): self.assertRaises(ValueError, sample, DATA, SimpleModel(), NmpfitStrategy)
def test_dict_compound_name(self): model = SimpleModel() parameter = {'a': 0, 'b': 1, 'c': prior.Uniform(0, 1)} model._convert_to_map(parameter, 'prefix') self.assertEqual(model._parameter_names[-1], 'prefix.c')
def test_map_transformed_prior_names(self): model = SimpleModel() base_prior = [prior.Uniform(0, 2, name='first'), prior.Uniform(1, 2)] transformed = {'trans': prior.TransformedPrior(np.maximum, base_prior)} parameter_map = model._convert_to_map(transformed) self.assertEqual(model._parameter_names[-2:], ['first', 'trans.1'])
def test_mapping_adds_to_model(self): model = SimpleModel() parameter = prior.Uniform(0, 1) model._convert_to_map(parameter, 'new name') self.assertEqual(model._parameters[-1], parameter) self.assertEqual(model._parameter_names[-1], "new name")