def test_pickle():
"""
Make sure models can be pickled are preserved when pickling
"""
a, b = parameters('a, b')
x, y = variables('x, y')
exact_model = Model({y: a * x ** b})
constraint = Model.as_constraint(Eq(a, b), exact_model)
num_model = CallableNumericalModel(
{y: a * x ** b}, independent_vars=[x], params=[a, b]
)
connected_num_model = CallableNumericalModel(
{y: a * x ** b}, connectivity_mapping={y: {x, a, b}}
)
# Test if lsoda args and kwargs are pickled too
ode_model = ODEModel({D(y, x): a * x + b}, {x: 0.0}, 3, 4, some_kwarg=True)
models = [exact_model, constraint, num_model, ode_model, connected_num_model]
for model in models:
new_model = pickle.loads(pickle.dumps(model))
# Compare signatures
assert model.__signature__ == new_model.__signature__
# Trigger the cached vars because we compare `__dict__` s
model.vars
new_model.vars
# Explicitly make sure the connectivity mapping is identical.
assert model.connectivity_mapping == new_model.connectivity_mapping
if not isinstance(model, ODEModel):
model.function_dict
model.vars_as_functions
new_model.function_dict
new_model.vars_as_functions
assert model.__dict__ == new_model.__dict__
def test_data_for_constraint(self):
"""
Test the signature handling when constraints are at play. Constraints
should take seperate data, but still kwargs that are not found in either
the model nor the constraints should raise an error.
"""
A, mu, sig = parameters('A, mu, sig')
x, y, Y = variables('x, y, Y')
model = Model({y: A * Gaussian(x, mu=mu, sig=sig)})
constraint = Model.as_constraint(Y, model, constraint_type=Eq)
np.random.seed(2)
xdata = np.random.normal(1.2, 2, 10)
ydata, xedges = np.histogram(xdata, bins=int(np.sqrt(len(xdata))),
density=True)
# Allowed
fit = Fit(model, x=xdata, y=ydata, Y=2, constraints=[constraint])
fit = Fit(model, x=xdata, y=ydata)
fit = Fit(model, x=xdata, objective=LogLikelihood)
# Not allowed
with self.assertRaises(TypeError):
fit = Fit(model, x=xdata, y=ydata, Y=2)
with self.assertRaises(TypeError):
fit = Fit(model, x=xdata, y=ydata, Y=2, Z=3, constraints=[constraint])
def test_pickle(self):
"""
Make sure models can be pickled are preserved when pickling
"""
a, b = parameters('a, b')
x, y = variables('x, y')
exact_model = Model({y: a * x ** b})
constraint = Model.as_constraint(Eq(a, b), exact_model)
num_model = CallableNumericalModel(
{y: a * x ** b}, independent_vars=[x], params=[a, b]
)
connected_num_model = CallableNumericalModel(
{y: a * x ** b}, connectivity_mapping={y: {x, a, b}}
)
# Test if lsoda args and kwargs are pickled too
ode_model = ODEModel({D(y, x): a * x + b}, {x: 0.0}, 3, 4, some_kwarg=True)
models = [exact_model, constraint, num_model, ode_model,
connected_num_model]
for model in models:
new_model = pickle.loads(pickle.dumps(model))
# Compare signatures
self.assertEqual(model.__signature__, new_model.__signature__)
# Trigger the cached vars because we compare `__dict__` s
model.vars
new_model.vars
# Explicitly make sure the connectivity mapping is identical.
self.assertEqual(model.connectivity_mapping,
new_model.connectivity_mapping)
if not isinstance(model, ODEModel):
model.function_dict
model.vars_as_functions
new_model.function_dict
new_model.vars_as_functions
self.assertEqual(model.__dict__, new_model.__dict__)
def test_minimizer_constraint_compatibility(self):
"""
Test if #156 has been solved, and test all the other constraint styles.
"""
x, y, z = variables('x, y, z')
a, b, c = parameters('a, b, c')
b.fixed = True
model = Model({z: a * x**2 - b * y**2 + c})
# Generate data, z has to be scalar for MinimizeModel to be happy
xdata = 3 #np.linspace(0, 10)
ydata = 5 # np.linspace(0, 10)
zdata = model(a=2, b=3, c=5, x=xdata, y=ydata).z
data_dict = {x: xdata, y: ydata, z: zdata}
# Equivalent ways of defining the same constraint
constraint_model = Model.as_constraint(a - c, model, constraint_type=Eq)
constraint_model.params = model.params
constraints = [
Eq(a, c),
MinimizeModel(constraint_model, data=data_dict),
constraint_model
]
objective = MinimizeModel(model, data=data_dict)
for constraint in constraints:
fit = SLSQP(objective, parameters=[a, b, c],
constraints=[constraint])
wrapped_constr = fit.wrapped_constraints[0]['fun'].model
self.assertIsInstance(wrapped_constr, Model)
self.assertEqual(wrapped_constr.params, model.params)
self.assertEqual(wrapped_constr.jacobian_model.params, model.params)
self.assertEqual(wrapped_constr.hessian_model.params, model.params)
# Set the data for the dependent var of the constraint to None
# Normally this is handled by Fit because here we interact with the
# Minimizer directly, it is up to us.
constraint_var = fit.wrapped_constraints[0]['fun'].model.dependent_vars[0]
objective.data[constraint_var] = None
fit.execute()
# No scipy style dicts allowed.
with self.assertRaises(TypeError):
fit = SLSQP(MinimizeModel(model, data={}),
parameters=[a, b, c],
constraints=[
{'type': 'eq', 'fun': lambda a, b, c: a - c}
]
)
def test_minimizer_constraint_compatibility():
"""
Test if #156 has been solved, and test all the other constraint styles.
"""
x, y, z = variables('x, y, z')
a, b, c = parameters('a, b, c')
b.fixed = True
model = Model({z: a * x**2 - b * y**2 + c})
# Generate data, z has to be scalar for MinimizeModel to be happy
xdata = 3 # np.linspace(0, 10)
ydata = 5 # np.linspace(0, 10)
zdata = model(a=2, b=3, c=5, x=xdata, y=ydata).z
data_dict = {x: xdata, y: ydata, z: zdata}
# Equivalent ways of defining the same constraint
constraint_model = Model.as_constraint(a - c, model, constraint_type=Eq)
constraint_model.params = model.params
constraints = [
Eq(a, c),
MinimizeModel(constraint_model, data=data_dict), constraint_model
]
objective = MinimizeModel(model, data=data_dict)
for constraint in constraints:
fit = SLSQP(objective, parameters=[a, b, c], constraints=[constraint])
wrapped_constr = fit.wrapped_constraints[0]['fun'].model
assert isinstance(wrapped_constr, Model)
assert wrapped_constr.params == model.params
assert wrapped_constr.jacobian_model.params == model.params
assert wrapped_constr.hessian_model.params == model.params
# Set the data for the dependent var of the constraint to None
# Normally this is handled by Fit because here we interact with the
# Minimizer directly, it is up to us.
constraint_var = fit.wrapped_constraints[0][
'fun'].model.dependent_vars[0]
objective.data[constraint_var] = None
fit.execute()
# No scipy style dicts allowed.
with pytest.raises(TypeError):
fit = SLSQP(MinimizeModel(model, data=data_dict),
parameters=[a, b, c],
constraints=[{
'type': 'eq',
'fun': lambda a, b, c: a - c
}])
def test_neg():
"""
Test negation of all model types
"""
x, y_1, y_2 = variables('x, y_1, y_2')
a, b = parameters('a, b')
model_dict = {y_2: a * x ** 2, y_1: 2 * x * b}
model = Model(model_dict)
model_neg = - model
for key in model:
assert model[key] == - model_neg[key]
# Constraints
constraint = Model.as_constraint(Eq(a * x, 2), model)
constraint_neg = - constraint
# for key in constraint:
assert constraint[constraint.dependent_vars[0]] == - constraint_neg[constraint_neg.dependent_vars[0]]
# ODEModel
odemodel = ODEModel({D(y_1, x): a * x}, initial={a: 1.0})
odemodel_neg = - odemodel
for key in odemodel:
assert odemodel[key] == - odemodel_neg[key]
# For models with interdependency, negation should only change the
# dependent components.
model_dict = {x: y_1**2, y_1: a * y_2 + b}
model = Model(model_dict)
model_neg = - model
for key in model:
if key in model.dependent_vars:
assert model[key] == - model_neg[key]
elif key in model.interdependent_vars:
assert model[key] == model_neg[key]
else:
pytest.fail()
def test_neg(self):
"""
Test negation of all model types
"""
x, y_1, y_2 = variables('x, y_1, y_2')
a, b = parameters('a, b')
model_dict = {y_2: a * x ** 2, y_1: 2 * x * b}
model = Model(model_dict)
model_neg = - model
for key in model:
self.assertEqual(model[key], - model_neg[key])
# Constraints
constraint = Model.as_constraint(Eq(a * x, 2), model)
constraint_neg = - constraint
# for key in constraint:
self.assertEqual(constraint[constraint.dependent_vars[0]], - constraint_neg[constraint_neg.dependent_vars[0]])
# ODEModel
odemodel = ODEModel({D(y_1, x): a * x}, initial={a: 1.0})
odemodel_neg = - odemodel
for key in odemodel:
self.assertEqual(odemodel[key], - odemodel_neg[key])
# For models with interdependency, negation should only change the
# dependent components.
model_dict = {x: y_1**2, y_1: a * y_2 + b}
model = Model(model_dict)
model_neg = - model
for key in model:
if key in model.dependent_vars:
self.assertEqual(model[key], - model_neg[key])
elif key in model.interdependent_vars:
self.assertEqual(model[key], model_neg[key])
else:
raise Exception('There should be no such variable')
def test_data_for_constraint():
"""
Test the signature handling when constraints are at play. Constraints
should take seperate data, but still kwargs that are not found in either
the model nor the constraints should raise an error.
"""
A, mu, sig = parameters('A, mu, sig')
x, y, Y = variables('x, y, Y')
model = Model({y: A * Gaussian(x, mu=mu, sig=sig)})
constraint = Model.as_constraint(Y, model, constraint_type=Eq)
np.random.seed(2)
xdata = np.random.normal(1.2, 2, 10)
ydata, xedges = np.histogram(xdata,
bins=int(np.sqrt(len(xdata))),
density=True)
# Allowed
fit = Fit(model, x=xdata, y=ydata, Y=2, constraints=[constraint])
assert isinstance(fit.objective, LeastSquares)
assert isinstance(fit.minimizer.constraints[0], MinimizeModel)
fit = Fit(model, x=xdata, y=ydata)
assert isinstance(fit.objective, LeastSquares)
fit = Fit(model, x=xdata, objective=LogLikelihood)
assert isinstance(fit.objective, LogLikelihood)
# Not allowed
with pytest.raises(TypeError):
fit = Fit(model, x=xdata, y=ydata, Y=2)
with pytest.raises(TypeError):
fit = Fit(model, x=xdata, y=ydata, Y=2, Z=3, constraints=[constraint])
with pytest.raises(TypeError):
fit = Fit(model, x=xdata, y=ydata, objective=LogLikelihood)
def test_constrained_dependent_on_model(self):
"""
For a simple Gaussian distribution, we test if Models of various types
can be used as constraints. Of particular interest are NumericalModels,
which can be used to fix the integral of the model during the fit to 1,
as it should be for a probability distribution.
:return:
"""
A, mu, sig = parameters('A, mu, sig')
x, y, Y = variables('x, y, Y')
i = Idx('i', (0, 1000))
sig.min = 0.0
model = Model({y: A * Gaussian(x, mu=mu, sig=sig)})
# Generate data, 100 samples from a N(1.2, 2) distribution
np.random.seed(2)
xdata = np.random.normal(1.2, 2, 1000)
ydata, xedges = np.histogram(xdata, bins=int(np.sqrt(len(xdata))), density=True)
xcentres = (xedges[1:] + xedges[:-1]) / 2
# Unconstrained fit
fit = Fit(model, x=xcentres, y=ydata)
unconstr_result = fit.execute()
# Constraints must be scalar models.
with self.assertRaises(ModelError):
Model.as_constraint([A - 1, sig - 1], model, constraint_type=Eq)
constraint_exact = Model.as_constraint(
A * sqrt(2 * sympy.pi) * sig - 1, model, constraint_type=Eq
)
# Only when explicitly asked, do models behave as constraints.
self.assertTrue(hasattr(constraint_exact, 'constraint_type'))
self.assertEqual(constraint_exact.constraint_type, Eq)
self.assertFalse(hasattr(model, 'constraint_type'))
# Now lets make some valid constraints and see if they are respected!
# TODO: These first two should be symbolical integrals over `y` instead,
# but currently this is not converted into a numpy/scipy function. So instead the first two are not valid constraints.
constraint_model = Model.as_constraint(A - 1, model, constraint_type=Eq)
constraint_exact = Eq(A, 1)
constraint_num = CallableNumericalModel.as_constraint(
{Y: lambda x, y: simps(y, x) - 1}, # Integrate using simps
model=model,
connectivity_mapping={Y: {x, y}},
constraint_type=Eq
)
# Test for all these different types of constraint.
for constraint in [constraint_model, constraint_exact, constraint_num]:
if not isinstance(constraint, Eq):
self.assertEqual(constraint.constraint_type, Eq)
xcentres = (xedges[1:] + xedges[:-1]) / 2
fit = Fit(model, x=xcentres, y=ydata, constraints=[constraint])
# Test if conversion into a constraint was done properly
fit_constraint = fit.constraints[0]
self.assertEqual(fit.model.params, fit_constraint.params)
self.assertEqual(fit_constraint.constraint_type, Eq)
con_map = fit_constraint.connectivity_mapping
if isinstance(constraint, CallableNumericalModel):
self.assertEqual(con_map, {Y: {x, y}, y: {x, mu, sig, A}})
self.assertEqual(fit_constraint.independent_vars, [x])
self.assertEqual(fit_constraint.dependent_vars, [Y])
self.assertEqual(fit_constraint.interdependent_vars, [y])
self.assertEqual(fit_constraint.params, [A, mu, sig])
else:
# ToDo: if these constraints can somehow be written as integrals
# depending on y and x this if/else should be removed.
self.assertEqual(con_map,
{fit_constraint.dependent_vars[0]: {A}})
self.assertEqual(fit_constraint.independent_vars, [])
self.assertEqual(len(fit_constraint.dependent_vars), 1)
self.assertEqual(fit_constraint.interdependent_vars, [])
self.assertEqual(fit_constraint.params, [A, mu, sig])
# Finally, test if the constraint worked
fit_result = fit.execute(options={'eps': 1e-15, 'ftol': 1e-10})
unconstr_value = fit.minimizer.wrapped_constraints[0]['fun'](**unconstr_result.params)
constr_value = fit.minimizer.wrapped_constraints[0]['fun'](**fit_result.params)
self.assertAlmostEqual(constr_value[0], 0.0, 10)
# And if it was very poorly met before
self.assertNotAlmostEqual(unconstr_value[0], 0.0, 2)
def test_constrained_dependent_on_model():
"""
For a simple Gaussian distribution, we test if Models of various types
can be used as constraints. Of particular interest are NumericalModels,
which can be used to fix the integral of the model during the fit to 1,
as it should be for a probability distribution.
:return:
"""
A, mu, sig = parameters('A, mu, sig')
x, y, Y = variables('x, y, Y')
i = Idx('i', (0, 1000))
sig.min = 0.0
model = GradientModel({y: A * Gaussian(x, mu=mu, sig=sig)})
# Generate data, 100 samples from a N(1.2, 2) distribution
np.random.seed(2)
xdata = np.random.normal(1.2, 2, 1000)
ydata, xedges = np.histogram(xdata,
bins=int(np.sqrt(len(xdata))),
density=True)
xcentres = (xedges[1:] + xedges[:-1]) / 2
# Unconstrained fit
fit = Fit(model, x=xcentres, y=ydata)
unconstr_result = fit.execute()
# Constraints must be scalar models.
with pytest.raises(ModelError):
Model.as_constraint([A - 1, sig - 1], model, constraint_type=Eq)
constraint_exact = Model.as_constraint(A * sqrt(2 * sympy.pi) * sig - 1,
model,
constraint_type=Eq)
# Only when explicitly asked, do models behave as constraints.
assert hasattr(constraint_exact, 'constraint_type')
assert constraint_exact.constraint_type == Eq
assert not hasattr(model, 'constraint_type')
# Now lets make some valid constraints and see if they are respected!
# FIXME These first two should be symbolical integrals over `y` instead,
# but currently this is not converted into a numpy/scipy function. So
# instead the first two are not valid constraints.
constraint_model = Model.as_constraint(A - 1, model, constraint_type=Eq)
constraint_exact = Eq(A, 1)
constraint_num = CallableNumericalModel.as_constraint(
{
Y: lambda x, y: simps(y, x) - 1
}, # Integrate using simps
model=model,
connectivity_mapping={Y: {x, y}},
constraint_type=Eq)
# Test for all these different types of constraint.
for constraint in [constraint_model, constraint_exact, constraint_num]:
if not isinstance(constraint, Eq):
assert constraint.constraint_type == Eq
xcentres = (xedges[1:] + xedges[:-1]) / 2
fit = Fit(model, x=xcentres, y=ydata, constraints=[constraint])
# Test if conversion into a constraint was done properly
fit_constraint = fit.constraints[0]
assert fit.model.params == fit_constraint.params
assert fit_constraint.constraint_type == Eq
con_map = fit_constraint.connectivity_mapping
if isinstance(constraint, CallableNumericalModel):
assert con_map == {Y: {x, y}, y: {x, mu, sig, A}}
assert fit_constraint.independent_vars == [x]
assert fit_constraint.dependent_vars == [Y]
assert fit_constraint.interdependent_vars == [y]
assert fit_constraint.params == [A, mu, sig]
else:
# TODO if these constraints can somehow be written as integrals
# depending on y and x this if/else should be removed.
assert con_map == {fit_constraint.dependent_vars[0]: {A}}
assert fit_constraint.independent_vars == []
assert len(fit_constraint.dependent_vars) == 1
assert fit_constraint.interdependent_vars == []
assert fit_constraint.params == [A, mu, sig]
# Finally, test if the constraint worked
fit_result = fit.execute(options={'eps': 1e-15, 'ftol': 1e-10})
unconstr_value = fit.minimizer.wrapped_constraints[0]['fun'](
**unconstr_result.params)
constr_value = fit.minimizer.wrapped_constraints[0]['fun'](
**fit_result.params)
# TODO because of a bug by pytest we have to solve it like this
assert constr_value[0] == pytest.approx(0, abs=1e-10)
# And if it was very poorly met before
assert not unconstr_value[0] == pytest.approx(0.0, 1e-1)
