def test_bounding(self):
guess = self.guess()
guess['center'] = Parameter(value=2, min=1.3)
true_values = self.true_values()
true_values['center'] = 1.3 # as close as it's allowed to get
result = self.model.fit(self.data, x=self.x, **guess)
assert_results_close(result.values, true_values, rtol=0.05)
def test_vary_false(self):
guess = self.guess()
guess['center'] = Parameter(value=1.3, vary=False)
true_values = self.true_values()
true_values['center'] = 1.3
result = self.model.fit(self.data, x=self.x, **guess)
assert_results_close(result.values, true_values, rtol=0.05)
def test_vary_false(self):
guess = self.guess()
guess['center'] = Parameter(value=1.3, vary=False)
true_values = self.true_values()
true_values['center'] = 1.3
result = self.model.fit(self.data, x=self.x, **guess)
assert_results_close(result.values, true_values, rtol=0.05)
def test_bounding(self):
guess = self.guess()
guess['center'] = Parameter(value=2, min=1.3)
true_values = self.true_values()
true_values['center'] = 1.3 # as close as it's allowed to get
result = self.model.fit(self.data, x=self.x, **guess)
assert_results_close(result.values, true_values, rtol=0.05)
def test_user_defined_gaussian_plus_constant(self):
data = self.data + 5
model = self.model + specified_models.Constant()
guess = self.guess()
guess['c'] = 10
true_values = self.true_values()
true_values['c'] = 5
result = model.fit(data, x=self.x, **guess)
assert_results_close(result.values, true_values)
def test_user_defined_gaussian_plus_constant(self):
data = self.data + 5
model = self.model + specified_models.Constant()
guess = self.guess()
guess['c'] = 10
true_values = self.true_values()
true_values['c'] = 5
result = model.fit(data, x=self.x, **guess)
assert_results_close(result.values, true_values)
def test_sum_of_two_gaussians(self):
# two user-defined gaussians
model1 = self.model
f2 = lambda x, amplitude_, center_, sigma_: gaussian(
x, amplitude_, center_, sigma_)
model2 = Model(f2, ['x'])
values1 = self.true_values()
values2 = self.true_values()
values2['sigma'] = 1.5
data = gaussian(x=self.x, **values1)
data += gaussian(x=self.x, **values2)
model = self.model + model2
values2 = {k + '_': v for k, v in values2.items()}
guess = {'sigma': Parameter(value=2, min=0), 'center': 1,
'amplitude': Parameter(value=3, min=0),
'sigma_': Parameter(value=1, min=0), 'center_': 1,
'amplitude_': Parameter(value=2.3)}
true_values = dict(list(values1.items()) + list(values2.items()))
result = model.fit(data, x=self.x, **guess)
assert_results_close(result.values, true_values)
# user-defined models with common parameter names
# cannot be added, and should raise
f = lambda: model1 + model1
self.assertRaises(NameError, f)
# two predefined_gaussians, using suffix to differentiate
model1 = specified_models.Gaussian(['x'])
model2 = specified_models.Gaussian(['x'], suffix='_')
model = model1 + model2
true_values = {'center': values1['center'],
'amplitude': values1['amplitude'],
'sigma': values1['sigma'],
'center_': values2['center_'],
'amplitude_': values2['amplitude_'],
'sigma_': values2['sigma_']}
guess = {'sigma': 2, 'center': 1, 'amplitude': 1,
'sigma_': 1, 'center_': 1, 'amplitude_': 1}
result = model.fit(data, x=self.x, **guess)
assert_results_close(result.values, true_values)
# without suffix, the names collide and Model should raise
model1 = specified_models.Gaussian(['x'])
model2 = specified_models.Gaussian(['x'])
f = lambda: model1 + model2
self.assertRaises(NameError, f)
def test_result_attributes(self):
# result.init_values
result = self.model.fit(self.data, x=self.x, **self.guess())
assert_results_close(result.values, self.true_values())
self.assertTrue(result.init_values == self.guess())
# result.init_params
params = self.model.params()
for param_name, value in self.guess().items():
params[param_name].value = value
self.assertTrue(result.init_params == params)
# result.best_fit
assert_allclose(result.best_fit, self.data, atol=self.noise.max())
# result.init_fit
init_fit = self.model.func(x=self.x, **self.guess())
assert_allclose(result.init_fit, init_fit)
# result.model
self.assertTrue(result.model is self.model)
def test_result_attributes(self):
# result.init_values
result = self.model.fit(self.data, x=self.x, **self.guess())
assert_results_close(result.values, self.true_values())
self.assertTrue(result.init_values == self.guess())
# result.init_params
params = self.model.params()
for param_name, value in self.guess().items():
params[param_name].value = value
self.assertTrue(result.init_params == params)
# result.best_fit
assert_allclose(result.best_fit, self.data, atol=self.noise.max())
# result.init_fit
init_fit = self.model.func(x=self.x, **self.guess())
assert_allclose(result.init_fit, init_fit)
# result.model
self.assertTrue(result.model is self.model)
def test_fit_with_parameters_obj(self):
params = self.model.params()
for param_name, value in self.guess().items():
params[param_name].value = value
result = self.model.fit(self.data, params, x=self.x)
assert_results_close(result.values, self.true_values())
def test_fit_with_keyword_params(self):
result = self.model.fit(self.data, x=self.x, **self.guess())
assert_results_close(result.values, self.true_values())
def test_fit(self):
model = self.model_instance
result = model.fit(self.data, x=self.x, **self.guess())
assert_results_close(result.values, self.true_values())
def test_fit_with_parameters_obj(self):
params = self.model.params()
for param_name, value in self.guess().items():
params[param_name].value = value
result = self.model.fit(self.data, params, x=self.x)
assert_results_close(result.values, self.true_values())
def test_fit_with_keyword_params(self):
result = self.model.fit(self.data, x=self.x, **self.guess())
assert_results_close(result.values, self.true_values())
def test_fit(self):
model = self.model_instance
result = model.fit(self.data, x=self.x, **self.guess())
assert_results_close(result.values, self.true_values())
def test_sum_of_two_gaussians(self):
# two user-defined gaussians
model1 = self.model
f2 = lambda x, height_, center_, sigma_: gaussian(
x, height_, center_, sigma_)
model2 = Model(f2, ['x'])
values1 = self.true_values()
values2 = self.true_values()
values2['sigma'] = 1.5
values2['height'] = 4
data = gaussian(x=self.x, **values1)
data += gaussian(x=self.x, **values2)
model = self.model + model2
values2 = {k + '_': v for k, v in values2.items()}
guess = {
'sigma': Parameter(value=2, min=0),
'center': 1,
'height': 1,
'sigma_': Parameter(value=1, min=0),
'center_': 1,
'height_': 1
}
true_values = dict(list(values1.items()) + list(values2.items()))
result = model.fit(data, x=self.x, **guess)
assert_results_close(result.values, true_values)
# user-defined models with common parameter names
# cannot be added, and should raise
f = lambda: model1 + model1
self.assertRaises(NameError, f)
# two predefined_gaussians, using suffix to differentiate
model1 = specified_models.Gaussian(['x'])
model2 = specified_models.Gaussian(['x'], suffix='_')
model = model1 + model2
true_values = {
'center': values1['center'],
'height': values1['height'],
'sigma': values1['sigma'],
'center_': values2['center_'],
'height_': values2['height_'],
'sigma_': values2['sigma_']
}
guess = {
'sigma': 2,
'center': 1,
'height': 1,
'sigma_': 1,
'center_': 1,
'height_': 1
}
result = model.fit(data, x=self.x, **guess)
assert_results_close(result.values, true_values)
# without suffix, the names collide and Model should raise
model1 = specified_models.Gaussian(['x'])
model2 = specified_models.Gaussian(['x'])
f = lambda: model1 + model2
self.assertRaises(NameError, f)
