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")
