def test_parameters_from_stack():
a = Parameter("a", 1)
b = Parameter("b", 2)
c = Parameter("c", 3)
pars = Parameters([a, b]) + Parameters([]) + Parameters([c])
assert pars.names == ["a", "b", "c"]
def test_get_subcovariance():
a = Parameter("a", 10)
b = Parameter("b", 20)
c = Parameter("c", 30)
pars_0 = Parameters([a, b, c])
pars_0.covariance = np.array([[2, 3, 4], [6, 7, 8], [10, 11, 12]])
pars_1 = Parameters([a, b])
assert_equal(pars_0.get_subcovariance(pars_1), np.array([[2, 3], [6, 7]]))
assert_equal(pars_0.get_subcovariance([c]), np.array([[12]]))
def test_set_subcovariance():
a = Parameter("a", 10)
b = Parameter("b", 20)
c = Parameter("c", 30)
pars_0 = Parameters([a, c, b])
pars_0.covariance = np.zeros((3, 3))
pars_1 = Parameters([a, b])
pars_1.covariance = np.array([[2, 3], [6, 7]])
pars_0.set_subcovariance(pars_1)
assert_equal(pars_0.covariance, np.array([[2, 0, 3], [0, 0, 0], [6, 0, 7]]))
def test_parameters_from_stack():
a = Parameter("a", 1)
b = Parameter("b", 2)
c = Parameter("c", 3)
pars = Parameters([a, b]) + Parameters([]) + Parameters([c])
assert pars.names == ["a", "b", "c"]
pars1 = Parameters.from_values([1, 2], covariance=np.full((2, 2), 2))
pars2 = Parameters.from_values([3, 4, 5], covariance=np.full((3, 3), 3))
pars = pars1 + pars2
assert_allclose(pars.values, [1, 2, 3, 4, 5])
assert_allclose(pars.covariance[0], [2, 2, 0, 0, 0])
assert_allclose(pars.covariance[4], [0, 0, 3, 3, 3])
def __init__(self, r_s=None, rho_s=1 * u.Unit("GeV / cm3")):
r_s = self.DEFAULT_SCALE_RADIUS if r_s is None else r_s
self.parameters = Parameters([
Parameter("r_s", u.Quantity(r_s)),
Parameter("rho_s", u.Quantity(rho_s))
])
def covariance(self, covariance):
self._covariance.data = covariance
for par in self.parameters:
pars = Parameters([par])
variance = self._covariance.get_subcovariance(pars)
par.error = np.sqrt(variance)
def covariance(self):
for par in self.parameters:
pars = Parameters([par])
covar = Covariance(pars, data=[[par.error ** 2]])
self._covariance.set_subcovariance(covar)
return self._covariance
def __init__(self, name=""):
self.name = name
self.parameters = Parameters(
[Parameter("x", 2),
Parameter("y", 3e2),
Parameter("z", 4e-2)])
self.data_shape = (1, )
def covariance_diagonal():
x = Parameter("x", 1, error=0.1)
y = Parameter("y", 2, error=0.2)
z = Parameter("z", 3, error=0.3)
parameters = Parameters([x, y, z])
return Covariance(parameters=parameters)
def test_unique_parameters():
a = Parameter("a", 1)
b = Parameter("b", 2)
c = Parameter("c", 3)
parameters = Parameters([a, b, a, c])
assert parameters.names == ["a", "b", "a", "c"]
parameters_unique = parameters.unique_parameters
assert parameters_unique.names == ["a", "b", "c"]
def parameters(self):
"""List of parameters (`~gammapy.modeling.Parameters`)"""
parameters = []
if self.model:
parameters += self.model.parameters
return Parameters(parameters)
def __init__(self, r_s=None, alpha=None, rho_s=1 * u.Unit("GeV / cm3")):
alpha = self.DEFAULT_ALPHA if alpha is None else alpha
r_s = self.DEFAULT_SCALE_RADIUS if r_s is None else r_s
self.parameters = Parameters([
Parameter("r_s", u.Quantity(r_s)),
Parameter("alpha", u.Quantity(alpha)),
Parameter("rho_s", u.Quantity(rho_s)),
])
def covariance(self):
self._check_covariance()
for par in self.parameters:
pars = Parameters([par])
error = np.nan_to_num(par.error**2, nan=1)
covar = Covariance(pars, data=[[error]])
self._covariance.set_subcovariance(covar)
return self._covariance
def _init_from_parameters(self, parameters):
"""Create model from list of parameters.
This should be called for models that generate
the parameters dynamically in ``__init__``,
like the ``NaimaSpectralModel``
"""
# TODO: should we pass through `Parameters` here? Why?
parameters = Parameters(parameters)
self._parameters = parameters
for parameter in parameters:
setattr(self, parameter.name, parameter)
def model(self, model):
self._model = model
if model is not None:
self._parameters = Parameters(self._model.parameters.parameters)
self._predictor = SpectrumEvaluator(
model=self.model,
livetime=self.livetime,
aeff=self.aeff,
e_true=self._energy_axis.edges,
edisp=self.edisp,
)
else:
self._parameters = None
self._predictor = None
def __init__(
self,
spectral_model,
name="bias",
bias=0.0,
):
self.spectral_model = spectral_model
self.parameter_name = name
self.bias_parameter = Parameter(name,
bias,
unit="",
min=-1.0,
max=2.0,
frozen=False)
parameters = Parameters([self.bias_parameter])
super()._init_from_parameters(parameters)
def test_parameters_s():
pars = Parameters([
Parameter("", 20, scale_method="scale10"),
Parameter("", 20, scale_method=None),
])
pars_dict = pars.to_dict()
pars.autoscale()
assert_allclose(pars[0].factor, 2)
assert_allclose(pars[0].scale, 10)
assert pars_dict[0]["scale_method"] == "scale10"
assert pars_dict[1]["scale_method"] is None
pars = Parameters.from_dict(pars_dict)
pars.autoscale()
assert_allclose(pars[0].factor, 2)
assert_allclose(pars[0].scale, 10)
assert pars[1].scale_method is None
pars.autoscale()
assert_allclose(pars[1].factor, 20)
assert_allclose(pars[1].scale, 1)
def __init__(
self,
spectral_model,
absorption,
parameter,
parameter_name="redshift",
alpha_norm=1.0,
):
self.spectral_model = spectral_model
self.absorption = absorption
self.parameter = parameter
self.parameter_name = parameter_name
min_ = self.absorption.param.min()
max_ = self.absorption.param.max()
par = Parameter(parameter_name,
parameter,
min=min_,
max=max_,
frozen=True)
alpha_norm = Parameter("alpha_norm", alpha_norm, frozen=True)
parameters = Parameters([par, alpha_norm])
super()._init_from_parameters(parameters)
def parameters(self):
"""Parameters (`~gammapy.modeling.Parameters`)"""
return Parameters(
[getattr(self, name) for name in self.default_parameters.names])
def pars():
x = Parameter("x", 2.1)
y = Parameter("y", 3.1, scale=1e5)
z = Parameter("z", 4.1, scale=1e-5)
return Parameters([x, y, z])
def covariance(covariance_diagonal):
x = covariance_diagonal.parameters["x"]
y = covariance_diagonal.parameters["y"]
parameters = Parameters([x, y])
data = np.ones((2, 2))
return Covariance(parameters=parameters, data=data)
def pars():
return Parameters([Parameter("spam", 42, "deg"), Parameter("ham", 99, "TeV")])
def parameters(self):
parameters = []
for skymodel in self.skymodels:
for p in skymodel.parameters:
parameters.append(p)
return Parameters(parameters)
def test_parameters_autoscale():
pars = Parameters([Parameter("", 20)])
pars.autoscale()
assert_allclose(pars[0].factor, 2)
assert_allclose(pars[0].scale, 10)
def parameters(self):
return Parameters([self.norm
]) + self.m1.parameters + self.m2.parameters
def __init__(self, m1, a=1, y=99):
self.m1 = m1
a = Parameter("a", a)
y = Parameter("y", y)
self.default_parameters = Parameters([a, y])
super().__init__(a=a, y=y)
def parameters(self):
return Parameters([self.a, self.y]) + self.m1.parameters
def __init_subclass__(cls, **kwargs):
# Add parameters list on the model sub-class (not instances)
cls.default_parameters = Parameters(
[_ for _ in cls.__dict__.values() if isinstance(_, Parameter)])
def __init__(self):
self.parameters = Parameters(
[Parameter("x", 2),
Parameter("y", 3e2),
Parameter("z", 4e-2)])
def spectral_model(self, model):
"""`~gammapy.modeling.models.SpectralModel`"""
self._spectral_model = model
self._parameters = Parameters(
self.spatial_model.parameters.parameters +
self.spectral_model.parameters.parameters)