def test_internal_delta():
p = Parameter('test_parameter',1.0)
p.min_value = None
p.max_value = None
p._get_internal_delta()
p = Parameter('test_parameter', 1.0, min_value=0.1, max_value=5.0, delta=0.2, desc='test',
free=False, unit=u.MeV, prior=Uniform_prior(), is_normalization=True, transformation=LogarithmicTransformation())
p._get_internal_delta()
with pytest.raises(AssertionError):
p = Parameter('test_parameter', 1.0, min_value=-1., max_value=5.0, delta=0.2, desc='test',
free=False, unit=u.MeV, prior=Uniform_prior(), is_normalization=True, transformation=LogarithmicTransformation())
p = Parameter('test_parameter', 1.0, min_value=None, max_value=5.0, delta=0.2, desc='test',
free=False, unit=u.MeV, prior=Uniform_prior(), is_normalization=True, transformation=LogarithmicTransformation())
p._get_internal_delta()
def set_model(self, likelihoodModel):
"""
Set the model and free the location parameters
:param likelihoodModel:
:return: None
"""
# set the standard likelihood model
super(BALROGLike, self).set_model(likelihoodModel)
# now free the position
# if it is needed
if self._free_position:
if self._verbose:
print("Freeing the position of %s and setting priors" %
self.name)
for key in self._like_model.point_sources.keys():
self._like_model.point_sources[key].position.ra.free = True
self._like_model.point_sources[key].position.dec.free = True
self._like_model.point_sources[
key].position.ra.prior = Uniform_prior(lower_bound=0.0,
upper_bound=360)
self._like_model.point_sources[
key].position.dec.prior = Cosine_Prior(lower_bound=-90.0,
upper_bound=90)
ra = self._like_model.point_sources[key].position.ra.value
dec = self._like_model.point_sources[key].position.dec.value
else:
for key in self._like_model.point_sources.keys():
self._like_model.point_sources[
key].position.ra.prior = Uniform_prior(lower_bound=0.0,
upper_bound=360)
self._like_model.point_sources[
key].position.dec.prior = Cosine_Prior(lower_bound=-90.0,
upper_bound=90)
ra = self._like_model.point_sources[key].position.ra.value
dec = self._like_model.point_sources[key].position.dec.value
self._rsp.set_location(ra, dec, cache=self._use_cache)
def test_input_output_with_external_parameters():
mg = ModelGetter()
m = mg.model
# Create an external parameter
fake_parameter = Parameter("external_parameter",
1.0,
min_value=-1.0,
max_value=1.0,
free=True)
# Link as equal (default)
m.add_external_parameter(fake_parameter)
# Save model
temp_file = "__test.yml"
m.save(temp_file, overwrite=True)
# Now reload it again
m_reloaded = load_model(temp_file)
os.remove(temp_file)
# Check that all sources have been recovered
assert m_reloaded.sources.keys() == m.sources.keys()
# Check that the external parameter have been recovered
assert 'external_parameter' in m_reloaded
# Remove external parameter
m.remove_external_parameter("external_parameter")
# Add a prior to the external parameter
fake_parameter.prior = Uniform_prior()
fake_parameter.value = -0.1
m.add_external_parameter(fake_parameter)
# Save model
temp_file = "__test.yml"
m.save(temp_file, overwrite=True)
# Now reload it again
m_reloaded = load_model(temp_file)
os.remove(temp_file)
# Check that all sources have been recovered
assert m_reloaded.sources.keys() == m.sources.keys()
# Check that the external parameter have been recovered
assert 'external_parameter' in m_reloaded
assert m.external_parameter.value == m_reloaded.external_parameter.value
def test_constructor_complete():
p = Parameter(
'test_parameter',
1.0,
min_value=-5.0,
max_value=5.0,
delta=0.2,
desc='test',
free=False,
unit=u.MeV,
prior=Uniform_prior(),
is_normalization=True,
)
assert p.min_value == -5.0
assert p.max_value == 5.0
assert p.value == 1.0
assert p.delta == 0.2
assert p.name == 'test_parameter'
assert p.description == 'test'
assert p.fix == True
assert p.free == False
assert p.has_prior() == True
assert p.unit == u.MeV
assert p.is_normalization
p.display()
def test_prior():
p1 = Parameter('test_parameter',
1.0,
min_value=-5.0,
max_value=5.0,
delta=0.2,
desc='test',
free=False,
unit='MeV')
my_prior = Uniform_prior()
p1.prior = my_prior
assert my_prior == p1.prior
custom_prior = lambda x: x**2
with pytest.raises(NotCallableOrErrorInCall):
p1.prior = custom_prior
invalid_prior = lambda x, y: x * y
with pytest.raises(NotCallableOrErrorInCall):
p1.prior = invalid_prior
# Test the set_uninformative_prior method
p1.min_value = None
p1.max_value = 100.0
with pytest.raises(ParameterMustHaveBounds):
p1.set_uninformative_prior(Uniform_prior)
p1.min_value = 0.0
p1.max_value = None
with pytest.raises(ParameterMustHaveBounds):
p1.set_uninformative_prior(Uniform_prior)
p1.min_value = 0.0
p1.max_value = 100.0
p1.set_uninformative_prior(Uniform_prior)
# Log-uniform cannot be used if minimum is 0.0
with pytest.raises(SettingOutOfBounds):
p1.set_uninformative_prior(Log_uniform_prior)
p1.min_value = 1.0
p1.set_uninformative_prior(Log_uniform_prior)
def test_input_output_basic():
mg = ModelGetter()
m = mg.model
temp_file = "__test.yml"
m.save(temp_file, overwrite=True)
# Now reload it again
m_reloaded = load_model(temp_file)
# Check that all sources have been recovered
assert list(m_reloaded.sources.keys()) == list(m.sources.keys())
os.remove(temp_file)
# Now check that saving twice with the same name issues an exception if overwrite is not True
m.save(temp_file, overwrite=True)
with pytest.raises(ModelFileExists):
m.save(temp_file, overwrite=False)
# Try to write in an impossible location and verify that we throw an exception
with pytest.raises(CannotWriteModel):
m.save("/dev/null/ciaps", overwrite=True)
# Add a prior to one of the parameters
list(m.free_parameters.values())[0].prior = Uniform_prior()
m.save(temp_file, overwrite=True)
new_m = load_model(temp_file)
assert (
list(m.free_parameters.values())[0].prior.to_dict()
== list(new_m.free_parameters.values())[0].prior.to_dict()
)
os.remove(temp_file)
# Free and fix parameters
m.one.position.ra.free = True
m.two.spectrum.main.shape.K.fix = True
m.save(temp_file, overwrite=True)
new_m = load_model(temp_file)
assert new_m.one.position.ra.free == True
assert new_m.two.spectrum.main.shape.K.fix == True
os.remove(temp_file)
def test_remove_prior():
p1 = Parameter('test_parameter', 1.0, min_value=-5.0, max_value=5.0,
delta=0.2, desc='test', free=False, unit='MeV')
my_prior = Uniform_prior()
p1.prior = my_prior
assert p1.has_prior()==True
# Now remove it
p1.prior = None
assert p1.has_prior()==False
def test_links_and_pickle():
import pickle
p_orig = Parameter('test_parameter',
1.0,
min_value=-5.0,
max_value=5.0,
delta=0.2,
desc='test',
free=False,
unit=u.MeV,
prior=Uniform_prior())
# Test the linkinking and pickle
# Add a link
x = Parameter('aux_variable', 1.0)
# ax + b
law = Line()
law.a = 2.0
law.b = 1.0
p_orig.add_auxiliary_variable(x, law)
# Now pickle and unpickle
d = pickle.dumps(p_orig)
p = pickle.loads(d)
assert p.has_auxiliary_variable() == True
assert p.value == 3.0
assert p.free == False
p.auxiliary_variable[0].value = 4.0
assert p.value == 6.0
# Check that assigning to the parameter doesn't produce any effect
p.value = -1.0
assert p.value == 6.0
def test_pickle():
from astromodels.core.cpickle_compatibility_layer import cPickle
p_orig = Parameter('test_parameter',
1.0,
min_value=-5.0,
max_value=5.0,
delta=0.2,
desc='test',
free=False,
unit=u.MeV,
prior=Uniform_prior())
# Add a callback
working_callback = Callback()
p_orig.add_callback(working_callback)
# Now pickle and unpickle
d = cPickle.dumps(p_orig)
p = cPickle.loads(d)
# Check that everything is fine
assert p.min_value == -5.0
assert p.max_value == 5.0
assert p.value == 1.0
assert p.delta == 0.2
assert p.name == 'test_parameter'
assert p.description == 'test'
assert p.fix == True
assert p.free == False
assert p.has_prior() == True
assert p.unit == u.MeV
# Test the callback
p.value = 2.0
callback = p.get_callbacks()[0]
assert callback._control_value == p.value
def _setup(self, user_setup_dict):
if user_setup_dict is None:
default_setup = {"live_points": max(100, self._Npar * 20)}
self._setup_dict = default_setup
else:
for key in user_setup_dict:
self._setup_dict[key] = user_setup_dict[key]
# We need to wrap the function, because multinest maximizes instead of minimizing
def func_wrapper(values, ndim, nparams):
# values is a wrapped C class. Extract from it the values in a python list
values_list = [values[i] for i in range(ndim)]
return self.function(*values_list) * (-1)
self._func_wrapper = func_wrapper
# Now we need to build the global prior function, which in this case is just a set of uniform priors
# MULTINEST priors are defined on the unit cube
# and should return the value in the bounds... not the
# probability.
# First build a uniform prior for each parameters
self._param_priors = collections.OrderedDict()
for parameter_name in self.parameters:
min_value, max_value = self.parameters[parameter_name].bounds
assert min_value is not None, (
"Minimum value of parameter %s is None. In order to use the Multinest "
"minimizer you need to define proper bounds for each "
"free parameter" % parameter_name)
assert max_value is not None, (
"Maximum value of parameter %s is None. In order to use the Multinest "
"minimizer you need to define proper bounds for each "
"free parameter" % parameter_name)
# Compute the difference in order of magnitudes between minimum and maximum
if min_value > 0:
orders_of_magnitude_span = math.log10(max_value) - math.log10(
min_value)
if orders_of_magnitude_span > 2:
# Use a Log-uniform prior
self._param_priors[parameter_name] = Log_uniform_prior(
lower_bound=min_value, upper_bound=max_value)
else:
# Use a uniform prior
self._param_priors[parameter_name] = Uniform_prior(
lower_bound=min_value, upper_bound=max_value)
else:
# Can only use a uniform prior
self._param_priors[parameter_name] = Uniform_prior(
lower_bound=min_value, upper_bound=max_value)
def prior(params, ndim, nparams):
for i, (parameter_name,
parameter) in enumerate(self.parameters.items()):
try:
params[i] = self._param_priors[
parameter_name].from_unit_cube(params[i])
except AttributeError:
raise RuntimeError(
"The prior you are trying to use for parameter %s is "
"not compatible with multinest" % parameter_name)
# Give a test run to the prior to check that it is working. If it crashes while multinest is going
# it will not stop multinest from running and generate thousands of exceptions (argh!)
n_dim = len(self.parameters)
_ = prior([0.5] * n_dim, n_dim, [])
self._prior = prior