def test_vector_none_fitting(self):
"""
Fit to a 3 component vector valued function with one variables data set
to None, without bounds or guesses.
"""
a, b, c = parameters('a, b, c')
a_i, b_i, c_i = variables('a_i, b_i, c_i')
model = {a_i: a, b_i: b, c_i: c}
xdata = np.array([
[10.1, 9., 10.5, 11.2, 9.5, 9.6, 10.],
[102.1, 101., 100.4, 100.8, 99.2, 100., 100.8],
[71.6, 73.2, 69.5, 70.2, 70.8, 70.6, 70.1],
])
fit_none = NumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=None,
)
fit = NumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=xdata[2],
)
fit_none_result = fit_none.execute()
fit_result = fit.execute()
self.assertAlmostEqual(fit_none_result.value(a), fit_result.value(a), 4)
self.assertAlmostEqual(fit_none_result.value(b), fit_result.value(b), 4)
# the parameter without data should be unchanged.
self.assertAlmostEqual(fit_none_result.value(c), 1.0)
def test_vector_fitting_guess(self):
"""
Tests fitting to a 3 component vector valued function, with guesses.
"""
a, b, c = parameters('a, b, c')
a.value = 10
b.value = 100
a_i, b_i, c_i = variables('a_i, b_i, c_i')
model = {a_i: a, b_i: b, c_i: c}
xdata = np.array([
[10.1, 9., 10.5, 11.2, 9.5, 9.6, 10.],
[102.1, 101., 100.4, 100.8, 99.2, 100., 100.8],
[71.6, 73.2, 69.5, 70.2, 70.8, 70.6, 70.1],
])
fit = NumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=xdata[2],
)
fit_result = fit.execute()
self.assertAlmostEqual(fit_result.value(a), np.mean(xdata[0]), 4)
self.assertAlmostEqual(fit_result.value(b), np.mean(xdata[1]), 4)
self.assertAlmostEqual(fit_result.value(c), np.mean(xdata[2]), 4)
def test_fitting(self):
"""
Tests fitting with NumericalLeastSquares. Makes sure that the resulting
objects and values are of the right type, and that the fit_result does
not have unexpected members.
"""
xdata = np.linspace(1, 10, 10)
ydata = 3*xdata**2
a = Parameter() # 3.1, min=2.5, max=3.5
b = Parameter()
x = Variable()
new = a*x**b
fit = NumericalLeastSquares(new, xdata, ydata)
fit_result = fit.execute()
self.assertIsInstance(fit_result, FitResults)
self.assertAlmostEqual(fit_result.value(a), 3.0)
self.assertAlmostEqual(fit_result.value(b), 2.0)
self.assertIsInstance(fit_result.stdev(a), float)
self.assertIsInstance(fit_result.stdev(b), float)
self.assertIsInstance(fit_result.r_squared, float)
self.assertEqual(fit_result.r_squared, 1.0) # by definition since there's no fuzzyness
def test_straight_line_analytical(self):
"""
Test symfit against a straight line, for which the parameters and their
uncertainties are known analytically. Assuming equal weights.
"""
data = [[0, 1], [1, 0], [3, 2], [5, 4]]
xdata, ydata = (np.array(i, dtype='float64') for i in zip(*data))
# x = np.arange(0, 100, 0.1)
# np.random.seed(10)
# y = 3.0*x + 105.0 + np.random.normal(size=x.shape)
dx = xdata - xdata.mean()
dy = ydata - ydata.mean()
mean_squared_x = np.mean(xdata**2) - np.mean(xdata)**2
mean_xy = np.mean(xdata * ydata) - np.mean(xdata)*np.mean(ydata)
a = mean_xy/mean_squared_x
b = ydata.mean() - a * xdata.mean()
self.assertAlmostEqual(a, 0.694915, 6) # values from Mathematica
self.assertAlmostEqual(b, 0.186441, 6)
S = np.sum((ydata - (a*xdata + b))**2)
var_a_exact = S/(len(xdata) * (len(xdata) - 2) * mean_squared_x)
var_b_exact = var_a_exact*np.mean(xdata**2)
a_exact = a
b_exact = b
# We will now compare these exact results with values from symfit, numerically
a, b = parameters('a, b')
x, y = variables('x, y')
model = {y: a*x + b}
fit = NumericalLeastSquares(model, x=xdata, y=ydata)#, absolute_sigma=False)
fit_result = fit.execute()
popt, pcov = curve_fit(lambda z, c, d: c * z + d, xdata, ydata,
jac=lambda z, c, d: np.transpose([xdata, np.ones_like(xdata)]))
# jac=lambda p, x, y, func: np.transpose([x, np.ones_like(x)]))
# Dfun=lambda p, x, y, func: print(p, func, x, y))
# curve_fit
self.assertAlmostEqual(a_exact, popt[0], 4)
self.assertAlmostEqual(b_exact, popt[1], 4)
self.assertAlmostEqual(var_a_exact, pcov[0][0], 6)
self.assertAlmostEqual(var_b_exact, pcov[1][1], 6)
self.assertAlmostEqual(a_exact, fit_result.value(a), 4)
self.assertAlmostEqual(b_exact, fit_result.value(b), 4)
self.assertAlmostEqual(var_a_exact, fit_result.variance(a), 6)
self.assertAlmostEqual(var_b_exact, fit_result.variance(b), 6)
# Do the fit with the LinearLeastSquares object
fit = LinearLeastSquares(model, x=xdata, y=ydata)
fit_result = fit.execute()
self.assertAlmostEqual(a_exact, fit_result.value(a), 4)
self.assertAlmostEqual(b_exact, fit_result.value(b), 4)
self.assertAlmostEqual(var_a_exact, fit_result.variance(a), 6)
self.assertAlmostEqual(var_b_exact, fit_result.variance(b), 6)
# Lets also make sure the entire covariance matrix is the same
for cov1, cov2 in zip(fit_result.params.covariance_matrix.flatten(), pcov.flatten()):
self.assertAlmostEqual(cov1, cov2)
def test_fitting(self):
xdata = np.linspace(1,10,10)
ydata = 3*xdata**2
a = Parameter() #3.1, min=2.5, max=3.5
b = Parameter()
x = Variable()
new = a*x**b
fit = NumericalLeastSquares(new, xdata, ydata)
self.assertTrue(issubclass(fit.model.chi_squared.__class__, sympy.Expr))
self.assertTrue(issubclass(fit.model.chi.__class__, sympy.Expr))
self.assertTrue(type(fit.model.numerical_chi_squared) is types.LambdaType)
self.assertTrue(type(fit.model.numerical_chi) is types.LambdaType)
fit_result = fit.execute()
self.assertIsInstance(fit_result, FitResults)
self.assertAlmostEqual(fit_result.value(a), 3.0)
self.assertAlmostEqual(fit_result.value(b), 2.0)
self.assertIsInstance(fit_result.stdev(a), float)
self.assertIsInstance(fit_result.stdev(b), float)
self.assertIsInstance(fit_result.r_squared, float)
self.assertEqual(fit_result.r_squared, 1.0) # by definition since there's no fuzzyness
# Test several illegal ways to access the data.
self.assertRaises(AttributeError, getattr, *[fit_result.params, 'a_fdska'])
self.assertRaises(AttributeError, getattr, *[fit_result.params, 'c'])
self.assertRaises(AttributeError, getattr, *[fit_result.params, 'a_stdev_stdev'])
self.assertRaises(AttributeError, getattr, *[fit_result.params, 'a_stdev_'])
self.assertRaises(AttributeError, getattr, *[fit_result.params, 'a__stdev'])
def test_simple_kinetics(self):
"""
Simple kinetics data to test fitting
"""
tdata = np.array([10, 26, 44, 70, 120])
adata = 10e-4 * np.array([44, 34, 27, 20, 14])
a, b, t = variables('a, b, t')
k, a0 = parameters('k, a0')
k.value = 0.01
# a0.value, a0.min, a0.max = 54 * 10e-4, 40e-4, 60e-4
a0 = 54 * 10e-4
model_dict = {
D(a, t): -k * a**2,
D(b, t): k * a**2,
}
ode_model = ODEModel(model_dict, initial={t: 0.0, a: a0, b: 0.0})
# Generate some data
tvec = np.linspace(0, 500, 1000)
fit = NumericalLeastSquares(ode_model, t=tdata, a=adata, b=None)
fit_result = fit.execute()
# print(fit_result)
self.assertAlmostEqual(fit_result.value(k), 4.302875e-01, 4)
self.assertAlmostEqual(fit_result.stdev(k), 6.447068e-03, 4)
fit = Fit(ode_model, t=tdata, a=adata, b=None)
fit_result = fit.execute()
# print(fit_result)
self.assertAlmostEqual(fit_result.value(k), 4.302875e-01, 4)
self.assertTrue(np.isnan(fit_result.stdev(k)))
def test_fitting(self):
"""
Tests fitting with NumericalLeastSquares. Makes sure that the resulting
objects and values are of the right type, and that the fit_result does
not have unexpected members.
"""
xdata = np.linspace(1, 10, 10)
ydata = 3 * xdata**2
a = Parameter() # 3.1, min=2.5, max=3.5
b = Parameter()
x = Variable()
new = a * x**b
fit = NumericalLeastSquares(new, xdata, ydata)
fit_result = fit.execute()
self.assertIsInstance(fit_result, FitResults)
self.assertAlmostEqual(fit_result.value(a), 3.0)
self.assertAlmostEqual(fit_result.value(b), 2.0)
self.assertIsInstance(fit_result.stdev(a), float)
self.assertIsInstance(fit_result.stdev(b), float)
self.assertIsInstance(fit_result.r_squared, float)
self.assertEqual(fit_result.r_squared,
1.0) # by definition since there's no fuzzyness
def test_vector_fitting(self):
"""
Tests fitting to a 3 component vector valued function, without bounds
or guesses.
"""
a, b, c = parameters('a, b, c')
a_i, b_i, c_i = variables('a_i, b_i, c_i')
model = {a_i: a, b_i: b, c_i: c}
xdata = np.array([
[10.1, 9., 10.5, 11.2, 9.5, 9.6, 10.],
[102.1, 101., 100.4, 100.8, 99.2, 100., 100.8],
[71.6, 73.2, 69.5, 70.2, 70.8, 70.6, 70.1],
])
fit = NumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=xdata[2],
)
fit_result = fit.execute()
self.assertAlmostEqual(fit_result.value(a), 9.985691, 6)
self.assertAlmostEqual(fit_result.value(b), 1.006143e+02, 4)
self.assertAlmostEqual(fit_result.value(c), 7.085713e+01, 5)
def test_simple_kinetics(self):
"""
Simple kinetics data to test fitting
"""
tdata = np.array([10, 26, 44, 70, 120])
adata = 10e-4 * np.array([44, 34, 27, 20, 14])
a, b, t = variables('a, b, t')
k, a0 = parameters('k, a0')
k.value = 0.01
# a0.value, a0.min, a0.max = 54 * 10e-4, 40e-4, 60e-4
a0 = 54 * 10e-4
model_dict = {
D(a, t): - k * a**2,
D(b, t): k * a**2,
}
ode_model = ODEModel(model_dict, initial={t: 0.0, a: a0, b: 0.0})
# Generate some data
tvec = np.linspace(0, 500, 1000)
fit = NumericalLeastSquares(ode_model, t=tdata, a=adata, b=None)
fit_result = fit.execute()
# print(fit_result)
self.assertAlmostEqual(fit_result.value(k), 4.302875e-01, 4)
self.assertAlmostEqual(fit_result.stdev(k), 6.447068e-03, 4)
fit = Fit(ode_model, t=tdata, a=adata, b=None)
fit_result = fit.execute()
# print(fit_result)
self.assertAlmostEqual(fit_result.value(k), 4.302875e-01, 4)
self.assertTrue(np.isnan(fit_result.stdev(k)))
def test_vector_fitting(self):
"""
Tests fitting to a 3 component vector valued function, without bounds
or guesses.
"""
a, b, c = parameters('a, b, c')
a_i, b_i, c_i = variables('a_i, b_i, c_i')
model = {a_i: a, b_i: b, c_i: c}
xdata = np.array([
[10.1, 9., 10.5, 11.2, 9.5, 9.6, 10.],
[102.1, 101., 100.4, 100.8, 99.2, 100., 100.8],
[71.6, 73.2, 69.5, 70.2, 70.8, 70.6, 70.1],
])
fit = NumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=xdata[2],
)
fit_result = fit.execute()
self.assertAlmostEqual(fit_result.value(a), 9.985691, 6)
self.assertAlmostEqual(fit_result.value(b), 1.006143e+02, 4)
self.assertAlmostEqual(fit_result.value(c), 7.085713e+01, 5)
def test_vector_fitting_guess(self):
"""
Tests fitting to a 3 component vector valued function, with guesses.
"""
a, b, c = parameters('a, b, c')
a.value = 10
b.value = 100
a_i, b_i, c_i = variables('a_i, b_i, c_i')
model = {a_i: a, b_i: b, c_i: c}
xdata = np.array([
[10.1, 9., 10.5, 11.2, 9.5, 9.6, 10.],
[102.1, 101., 100.4, 100.8, 99.2, 100., 100.8],
[71.6, 73.2, 69.5, 70.2, 70.8, 70.6, 70.1],
])
fit = NumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=xdata[2],
)
fit_result = fit.execute()
self.assertAlmostEqual(fit_result.value(a), np.mean(xdata[0]), 4)
self.assertAlmostEqual(fit_result.value(b), np.mean(xdata[1]), 4)
self.assertAlmostEqual(fit_result.value(c), np.mean(xdata[2]), 4)
def test_gaussian_2d_fitting(self):
"""
Tests fitting to a scalar gaussian function with 2 independent
variables. Very sensitive to initial guesses, and if they are chosen too
restrictive ConstrainedNumericalLeastSquares actually throws a tantrum.
It therefore appears to be more sensitive than NumericalLeastSquares.
"""
mean = (0.6, 0.4) # x, y mean 0.6, 0.4
cov = [[0.2**2, 0], [0, 0.1**2]]
np.random.seed(0)
data = np.random.multivariate_normal(mean, cov, 100000)
# Insert them as y,x here as np f***s up cartesian conventions.
ydata, xedges, yedges = np.histogram2d(data[:, 0],
data[:, 1],
bins=100,
range=[[0.0, 1.0], [0.0, 1.0]])
xcentres = (xedges[:-1] + xedges[1:]) / 2
ycentres = (yedges[:-1] + yedges[1:]) / 2
# Make a valid grid to match ydata
xx, yy = np.meshgrid(xcentres, ycentres, sparse=False, indexing='ij')
x0 = Parameter(value=mean[0], min=0.0, max=1.0)
sig_x = Parameter(0.2, min=0.0, max=0.3)
y0 = Parameter(value=mean[1], min=0.0, max=1.0)
sig_y = Parameter(0.1, min=0.0, max=0.3)
A = Parameter(value=np.mean(ydata), min=0.0)
x = Variable()
y = Variable()
g = Variable()
model = Model({g: A * Gaussian(x, x0, sig_x) * Gaussian(y, y0, sig_y)})
fit = ConstrainedNumericalLeastSquares(model, x=xx, y=yy, g=ydata)
fit_result = fit.execute()
self.assertAlmostEqual(fit_result.value(x0), np.mean(data[:, 0]), 3)
self.assertAlmostEqual(fit_result.value(y0), np.mean(data[:, 1]), 3)
self.assertAlmostEqual(np.abs(fit_result.value(sig_x)),
np.std(data[:, 0]), 2)
self.assertAlmostEqual(np.abs(fit_result.value(sig_y)),
np.std(data[:, 1]), 2)
self.assertGreaterEqual(fit_result.r_squared, 0.96)
# Compare with industry standard MINPACK
fit_std = NumericalLeastSquares(model, x=xx, y=yy, g=ydata)
fit_std_result = fit_std.execute()
self.assertAlmostEqual(fit_std_result.value(x0), fit_result.value(x0),
4)
self.assertAlmostEqual(fit_std_result.value(y0), fit_result.value(y0),
4)
self.assertAlmostEqual(fit_std_result.value(sig_x),
fit_result.value(sig_x), 4)
self.assertAlmostEqual(fit_std_result.value(sig_y),
fit_result.value(sig_y), 4)
self.assertAlmostEqual(fit_std_result.r_squared, fit_result.r_squared,
4)
def test_gaussian_2d_fitting(self):
"""
Tests fitting to a scalar gaussian function with 2 independent
variables. Very sensitive to initial guesses, and if they are chosen too
restrictive ConstrainedNumericalLeastSquares actually throws a tantrum.
It therefore appears to be more sensitive than NumericalLeastSquares.
"""
mean = (0.6, 0.4) # x, y mean 0.6, 0.4
cov = [[0.2**2, 0], [0, 0.1**2]]
np.random.seed(0)
data = np.random.multivariate_normal(mean, cov, 100000)
# Insert them as y,x here as np f***s up cartesian conventions.
ydata, xedges, yedges = np.histogram2d(data[:, 0], data[:, 1], bins=100,
range=[[0.0, 1.0], [0.0, 1.0]])
xcentres = (xedges[:-1] + xedges[1:]) / 2
ycentres = (yedges[:-1] + yedges[1:]) / 2
# Make a valid grid to match ydata
xx, yy = np.meshgrid(xcentres, ycentres, sparse=False, indexing='ij')
x0 = Parameter(value=mean[0], min=0.0, max=1.0)
sig_x = Parameter(0.2, min=0.0, max=0.3)
y0 = Parameter(value=mean[1], min=0.0, max=1.0)
sig_y = Parameter(0.1, min=0.0, max=0.3)
A = Parameter(value=np.mean(ydata), min=0.0)
x = Variable()
y = Variable()
g = Variable()
model = Model({g: A * Gaussian(x, x0, sig_x) * Gaussian(y, y0, sig_y)})
fit = ConstrainedNumericalLeastSquares(model, x=xx, y=yy, g=ydata)
fit_result = fit.execute()
self.assertAlmostEqual(fit_result.value(x0), np.mean(data[:, 0]), 3)
self.assertAlmostEqual(fit_result.value(y0), np.mean(data[:, 1]), 3)
self.assertAlmostEqual(np.abs(fit_result.value(sig_x)), np.std(data[:, 0]), 2)
self.assertAlmostEqual(np.abs(fit_result.value(sig_y)), np.std(data[:, 1]), 2)
self.assertGreaterEqual(fit_result.r_squared, 0.96)
# Compare with industry standard MINPACK
fit_std = NumericalLeastSquares(model, x=xx, y=yy, g=ydata)
fit_std_result = fit_std.execute()
self.assertAlmostEqual(fit_std_result.value(x0), fit_result.value(x0), 4)
self.assertAlmostEqual(fit_std_result.value(y0), fit_result.value(y0), 4)
self.assertAlmostEqual(fit_std_result.value(sig_x), fit_result.value(sig_x), 4)
self.assertAlmostEqual(fit_std_result.value(sig_y), fit_result.value(sig_y), 4)
self.assertAlmostEqual(fit_std_result.r_squared, fit_result.r_squared, 4)
def test_error_advanced(self):
"""
Compare the error propagation of ConstrainedNumericalLeastSquares against
NumericalLeastSquares.
Models an example from the mathematica docs and try's to replicate it:
http://reference.wolfram.com/language/howto/FitModelsWithMeasurementErrors.html
"""
data = [[0.9, 6.1, 9.5], [3.9, 6., 9.7], [0.3, 2.8,
6.6], [1., 2.2, 5.9],
[1.8, 2.4, 7.2], [9., 1.7, 7.], [7.9, 8., 10.4],
[4.9, 3.9, 9.], [2.3, 2.6, 7.4], [4.7, 8.4, 10.]]
xdata, ydata, zdata = [np.array(data) for data in zip(*data)]
# errors = np.array([.4, .4, .2, .4, .1, .3, .1, .2, .2, .2])
a = Parameter(3.0)
b = Parameter(0.9)
c = Parameter(5.0)
x = Variable()
y = Variable()
z = Variable()
model = {z: a * log(b * x + c * y)}
const_fit = ConstrainedNumericalLeastSquares(model,
xdata,
ydata,
zdata,
absolute_sigma=False)
const_result = const_fit.execute()
fit = NumericalLeastSquares(model,
xdata,
ydata,
zdata,
absolute_sigma=False)
std_result = fit.execute()
self.assertEqual(const_fit.absolute_sigma, fit.absolute_sigma)
self.assertAlmostEqual(const_result.value(a), std_result.value(a), 4)
self.assertAlmostEqual(const_result.value(b), std_result.value(b), 4)
self.assertAlmostEqual(const_result.value(c), std_result.value(c), 4)
self.assertAlmostEqual(const_result.stdev(a), std_result.stdev(a), 4)
self.assertAlmostEqual(const_result.stdev(b), std_result.stdev(b), 4)
self.assertAlmostEqual(const_result.stdev(c), std_result.stdev(c), 4)
def test_named_fitting(self):
"""
Make sure that fitting with NumericalLeastSquares works using a dict
as model and that the resulting fit_result is of the right type.
"""
xdata = np.linspace(1, 10, 10)
ydata = 3 * xdata**2
a = Parameter(1.0)
b = Parameter(2.5)
x, y = variables('x, y')
model = {y: a * x**b}
fit = NumericalLeastSquares(model, x=xdata, y=ydata)
fit_result = fit.execute()
self.assertIsInstance(fit_result, FitResults)
self.assertAlmostEqual(fit_result.value(a), 3.0)
self.assertAlmostEqual(fit_result.value(b), 2.0)
def test_named_fitting(self):
"""
Make sure that fitting with NumericalLeastSquares works using a dict
as model and that the resulting fit_result is of the right type.
"""
xdata = np.linspace(1, 10, 10)
ydata = 3*xdata**2
a = Parameter(1.0)
b = Parameter(2.5)
x, y = variables('x, y')
model = {y: a*x**b}
fit = NumericalLeastSquares(model, x=xdata, y=ydata)
fit_result = fit.execute()
self.assertIsInstance(fit_result, FitResults)
self.assertAlmostEqual(fit_result.value(a), 3.0)
self.assertAlmostEqual(fit_result.value(b), 2.0)
def test_param_error_analytical(self):
"""
Take an example in which the parameter errors are known and see if
`ConstrainedNumericalLeastSquares` reproduces them.
It also needs to support the absolute_sigma argument.
"""
N = 10000
sigma = 25.0
xn = np.arange(N, dtype=np.float)
np.random.seed(110)
yn = np.random.normal(size=xn.shape, scale=sigma)
a = Parameter()
y = Variable()
model = {y: a}
constr_fit = ConstrainedNumericalLeastSquares(model, y=yn, sigma_y=sigma)
constr_result = constr_fit.execute()
fit = NumericalLeastSquares(model, y=yn, sigma_y=sigma)
fit_result = fit.execute()
self.assertAlmostEqual(fit_result.value(a), constr_result.value(a), 5)
self.assertAlmostEqual(fit_result.stdev(a), constr_result.stdev(a), 5)
# Analytical answer for mean of N(0,sigma):
sigma_mu = sigma/N**0.5
# self.assertAlmostEqual(fit_result.value(a), mu, 5)
self.assertAlmostEqual(fit_result.value(a), np.mean(yn), 5)
self.assertAlmostEqual(fit_result.stdev(a), sigma_mu, 5)
# Compare for absolute_sigma = False.
constr_fit = ConstrainedNumericalLeastSquares(model, y=yn, sigma_y=sigma, absolute_sigma=False)
constr_result = constr_fit.execute()
fit = NumericalLeastSquares(model, y=yn, sigma_y=sigma, absolute_sigma=False)
fit_result = fit.execute()
self.assertAlmostEqual(fit_result.value(a), constr_result.value(a), 5)
self.assertAlmostEqual(fit_result.stdev(a), constr_result.stdev(a), 5)
def test_gaussian_2d_fitting(self):
"""
Tests fitting to a scalar gaussian function with 2 independent
variables.
"""
mean = (0.6, 0.4) # x, y mean 0.6, 0.4
cov = [[0.2**2, 0], [0, 0.1**2]]
data = np.random.multivariate_normal(mean, cov, 1000000)
# Insert them as y,x here as np f***s up cartesian conventions.
ydata, xedges, yedges = np.histogram2d(data[:, 0],
data[:, 1],
bins=100,
range=[[0.0, 1.0], [0.0, 1.0]])
xcentres = (xedges[:-1] + xedges[1:]) / 2
ycentres = (yedges[:-1] + yedges[1:]) / 2
# Make a valid grid to match ydata
xx, yy = np.meshgrid(xcentres, ycentres, sparse=False, indexing='ij')
x0 = Parameter(value=mean[0])
sig_x = Parameter(min=0.0)
x = Variable()
y0 = Parameter(value=mean[1])
sig_y = Parameter(min=0.0)
A = Parameter(min=1, value=100)
y = Variable()
g = Variable()
# g = A * Gaussian(x, x0, sig_x) * Gaussian(y, y0, sig_y)
model = Model({g: A * Gaussian(x, x0, sig_x) * Gaussian(y, y0, sig_y)})
fit = NumericalLeastSquares(model, x=xx, y=yy, g=ydata)
fit_result = fit.execute()
self.assertAlmostEqual(fit_result.value(x0), np.mean(data[:, 0]), 1)
self.assertAlmostEqual(fit_result.value(y0), np.mean(data[:, 1]), 1)
self.assertAlmostEqual(np.abs(fit_result.value(sig_x)),
np.std(data[:, 0]), 1)
self.assertAlmostEqual(np.abs(fit_result.value(sig_y)),
np.std(data[:, 1]), 1)
self.assertGreaterEqual(fit_result.r_squared, 0.99)
def test_fitting(self):
xdata = np.linspace(1, 10, 10)
ydata = 3 * xdata**2
a = Parameter() #3.1, min=2.5, max=3.5
b = Parameter()
x = Variable()
new = a * x**b
fit = NumericalLeastSquares(new, xdata, ydata)
self.assertTrue(issubclass(fit.model.chi_squared.__class__,
sympy.Expr))
self.assertTrue(issubclass(fit.model.chi.__class__, sympy.Expr))
self.assertTrue(
type(fit.model.numerical_chi_squared) is types.LambdaType)
self.assertTrue(type(fit.model.numerical_chi) is types.LambdaType)
fit_result = fit.execute()
self.assertIsInstance(fit_result, FitResults)
self.assertAlmostEqual(fit_result.value(a), 3.0)
self.assertAlmostEqual(fit_result.value(b), 2.0)
self.assertIsInstance(fit_result.stdev(a), float)
self.assertIsInstance(fit_result.stdev(b), float)
self.assertIsInstance(fit_result.r_squared, float)
self.assertEqual(fit_result.r_squared,
1.0) # by definition since there's no fuzzyness
# Test several illegal ways to access the data.
self.assertRaises(AttributeError, getattr,
*[fit_result.params, 'a_fdska'])
self.assertRaises(AttributeError, getattr, *[fit_result.params, 'c'])
self.assertRaises(AttributeError, getattr,
*[fit_result.params, 'a_stdev_stdev'])
self.assertRaises(AttributeError, getattr,
*[fit_result.params, 'a_stdev_'])
self.assertRaises(AttributeError, getattr,
*[fit_result.params, 'a__stdev'])
def test_error_advanced(self):
"""
Compare the error propagation of ConstrainedNumericalLeastSquares against
NumericalLeastSquares.
Models an example from the mathematica docs and try's to replicate it:
http://reference.wolfram.com/language/howto/FitModelsWithMeasurementErrors.html
"""
data = [
[0.9, 6.1, 9.5], [3.9, 6., 9.7], [0.3, 2.8, 6.6],
[1., 2.2, 5.9], [1.8, 2.4, 7.2], [9., 1.7, 7.],
[7.9, 8., 10.4], [4.9, 3.9, 9.], [2.3, 2.6, 7.4],
[4.7, 8.4, 10.]
]
xdata, ydata, zdata = [np.array(data) for data in zip(*data)]
# errors = np.array([.4, .4, .2, .4, .1, .3, .1, .2, .2, .2])
a = Parameter(3.0)
b = Parameter(0.9)
c = Parameter(5.0)
x = Variable()
y = Variable()
z = Variable()
model = {z: a * log(b * x + c * y)}
const_fit = ConstrainedNumericalLeastSquares(model, xdata, ydata, zdata, absolute_sigma=False)
const_result = const_fit.execute()
fit = NumericalLeastSquares(model, xdata, ydata, zdata, absolute_sigma=False)
std_result = fit.execute()
self.assertEqual(const_fit.absolute_sigma, fit.absolute_sigma)
self.assertAlmostEqual(const_result.value(a), std_result.value(a), 4)
self.assertAlmostEqual(const_result.value(b), std_result.value(b), 4)
self.assertAlmostEqual(const_result.value(c), std_result.value(c), 4)
self.assertAlmostEqual(const_result.stdev(a), std_result.stdev(a), 4)
self.assertAlmostEqual(const_result.stdev(b), std_result.stdev(b), 4)
self.assertAlmostEqual(const_result.stdev(c), std_result.stdev(c), 4)
def test_gaussian_2d_fitting(self):
"""
Tests fitting to a scalar gaussian function with 2 independent
variables.
"""
mean = (0.6, 0.4) # x, y mean 0.6, 0.4
cov = [[0.2**2, 0], [0, 0.1**2]]
data = np.random.multivariate_normal(mean, cov, 1000000)
# Insert them as y,x here as np f***s up cartesian conventions.
ydata, xedges, yedges = np.histogram2d(data[:, 0], data[:, 1], bins=100,
range=[[0.0, 1.0], [0.0, 1.0]])
xcentres = (xedges[:-1] + xedges[1:]) / 2
ycentres = (yedges[:-1] + yedges[1:]) / 2
# Make a valid grid to match ydata
xx, yy = np.meshgrid(xcentres, ycentres, sparse=False, indexing='ij')
x0 = Parameter(value=mean[0])
sig_x = Parameter(min=0.0)
x = Variable()
y0 = Parameter(value=mean[1])
sig_y = Parameter(min=0.0)
A = Parameter(min=1, value=100)
y = Variable()
g = Variable()
# g = A * Gaussian(x, x0, sig_x) * Gaussian(y, y0, sig_y)
model = Model({g: A * Gaussian(x, x0, sig_x) * Gaussian(y, y0, sig_y)})
fit = NumericalLeastSquares(model, x=xx, y=yy, g=ydata)
fit_result = fit.execute()
self.assertAlmostEqual(fit_result.value(x0), np.mean(data[:, 0]), 1)
self.assertAlmostEqual(fit_result.value(y0), np.mean(data[:, 1]), 1)
self.assertAlmostEqual(np.abs(fit_result.value(sig_x)), np.std(data[:, 0]), 1)
self.assertAlmostEqual(np.abs(fit_result.value(sig_y)), np.std(data[:, 1]), 1)
self.assertGreaterEqual(fit_result.r_squared, 0.99)
def test_weights(self):
"""
Compare NumericalLeastSquares with LinearLeastSquares to see if errors
are implemented consistently.
"""
from symfit import Variable, Parameter, Fit
t_data = np.array([1.4, 2.1, 2.6, 3.0, 3.3])
y_data = np.array([10, 20, 30, 40, 50])
sigma = 0.2
n = np.array([5, 3, 8, 15, 30])
sigma_t = sigma / np.sqrt(n)
# We now define our model
t, y = variables("t, y")
b = Parameter()
sqrt_g_inv = Parameter() # sqrt_g_inv = sqrt(1/g). Currently needed to linearize.
# t_model = (2 * y / g)**0.5
t_model = {t: 2 * y ** 0.5 * sqrt_g_inv + b}
# Different sigma for every point
fit = NumericalLeastSquares(t_model, y=y_data, t=t_data, sigma_t=sigma_t, absolute_sigma=False)
num_result_rel = fit.execute()
fit = NumericalLeastSquares(t_model, y=y_data, t=t_data, sigma_t=sigma_t, absolute_sigma=True)
num_result = fit.execute()
# cov matrix should now be different
for cov1, cov2 in zip(
num_result_rel.params.covariance_matrix.flatten(), num_result.params.covariance_matrix.flatten()
):
# Make the absolute cov relative to see if it worked.
ss_res = np.sum(num_result_rel.infodict["fvec"] ** 2)
degrees_of_freedom = len(fit.data[fit.model.dependent_vars[0].name]) - len(fit.model.params)
s_sq = ss_res / degrees_of_freedom
self.assertAlmostEqual(cov1, cov2 * s_sq)
# print(fit.model.numerical_chi_jacobian[0](sqrt_g_inv=1, **fit.data))
fit = LinearLeastSquares(t_model, y=y_data, t=t_data, sigma_t=sigma_t)
fit_result = fit.execute()
self.assertAlmostEqual(num_result.value(sqrt_g_inv), fit_result.value(sqrt_g_inv))
self.assertAlmostEqual(num_result.value(b), fit_result.value(b))
# for cov1, cov2 in zip(num_result.params.covariance_matrix.flatten(), fit_result.params.covariance_matrix.flatten()):
# self.assertAlmostEqual(cov1, cov2)
# print(cov1, cov2)
for cov1, cov2 in zip(
num_result.params.covariance_matrix.flatten(), fit_result.params.covariance_matrix.flatten()
):
self.assertAlmostEqual(cov1, cov2)
def test_param_error_analytical(self):
"""
Take an example in which the parameter errors are known and see if
`ConstrainedNumericalLeastSquares` reproduces them.
It also needs to support the absolute_sigma argument.
"""
N = 10000
sigma = 25.0
xn = np.arange(N, dtype=np.float)
np.random.seed(110)
yn = np.random.normal(size=xn.shape, scale=sigma)
a = Parameter()
y = Variable()
model = {y: a}
constr_fit = ConstrainedNumericalLeastSquares(model,
y=yn,
sigma_y=sigma)
constr_result = constr_fit.execute()
fit = NumericalLeastSquares(model, y=yn, sigma_y=sigma)
fit_result = fit.execute()
self.assertAlmostEqual(fit_result.value(a), constr_result.value(a), 5)
self.assertAlmostEqual(fit_result.stdev(a), constr_result.stdev(a), 5)
# Analytical answer for mean of N(0,sigma):
sigma_mu = sigma / N**0.5
# self.assertAlmostEqual(fit_result.value(a), mu, 5)
self.assertAlmostEqual(fit_result.value(a), np.mean(yn), 5)
self.assertAlmostEqual(fit_result.stdev(a), sigma_mu, 5)
# Compare for absolute_sigma = False.
constr_fit = ConstrainedNumericalLeastSquares(model,
y=yn,
sigma_y=sigma,
absolute_sigma=False)
constr_result = constr_fit.execute()
fit = NumericalLeastSquares(model,
y=yn,
sigma_y=sigma,
absolute_sigma=False)
fit_result = fit.execute()
self.assertAlmostEqual(fit_result.value(a), constr_result.value(a), 5)
self.assertAlmostEqual(fit_result.stdev(a), constr_result.stdev(a), 5)
def test_nonlinearfit(self):
"""
Compare NumericalLeastSquares with LinearLeastSquares to see if errors
are implemented consistently.
"""
from symfit import Variable, Parameter, Fit
t_data = np.array([1.4, 2.1, 2.6, 3.0, 3.3])
y_data = np.array([10, 20, 30, 40, 50])
sigma = 0.2
n = np.array([5, 3, 8, 15, 30])
sigma_t = sigma / np.sqrt(n)
# We now define our model
t, y = variables('t, y')
g = Parameter(9.0)
t_model = {t: (2 * y / g)**0.5}
# Different sigma for every point
fit = NonLinearLeastSquares(t_model,
y=y_data,
t=t_data,
sigma_t=sigma_t)
import time
tick = time.time()
fit_result = fit.execute()
# print(time.time() - tick)
fit = NumericalLeastSquares(t_model,
y=y_data,
t=t_data,
sigma_t=sigma_t)
tick = time.time()
num_result = fit.execute()
# print(time.time() - tick)
self.assertAlmostEqual(num_result.value(g), fit_result.value(g))
for cov1, cov2 in zip(num_result.covariance_matrix.flatten(),
fit_result.covariance_matrix.flatten()):
self.assertAlmostEqual(cov1, cov2)
def test_vector_none_fitting(self):
"""
Fit to a 3 component vector valued function with one variables data set
to None, without bounds or guesses.
"""
a, b, c = parameters('a, b, c')
a_i, b_i, c_i = variables('a_i, b_i, c_i')
model = {a_i: a, b_i: b, c_i: c}
xdata = np.array([
[10.1, 9., 10.5, 11.2, 9.5, 9.6, 10.],
[102.1, 101., 100.4, 100.8, 99.2, 100., 100.8],
[71.6, 73.2, 69.5, 70.2, 70.8, 70.6, 70.1],
])
fit_none = NumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=None,
)
fit = NumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=xdata[2],
)
fit_none_result = fit_none.execute()
fit_result = fit.execute()
self.assertAlmostEqual(fit_none_result.value(a), fit_result.value(a),
4)
self.assertAlmostEqual(fit_none_result.value(b), fit_result.value(b),
4)
# the parameter without data should be unchanged.
self.assertAlmostEqual(fit_none_result.value(c), 1.0)
def test_vector_parameter_error(self):
"""
Tests `ConstrainedNumericalLeastSquares` parameter error estimation with
vector models. This is done by using the typical angles of a triangle
example. For completeness, we throw in covariance between the angles.
As it stands now, `ConstrainedNumericalLeastSquares` is able to correctly
predict the values of the parameters an their standard deviations, but
it is not able to give the covariances. Those are therefore returned as
nan, to prevent people from citing them as 0.0.
"""
N = 10000
a, b, c = parameters('a, b, c')
a_i, b_i, c_i = variables('a_i, b_i, c_i')
model = {a_i: a, b_i: b, c_i: c}
np.random.seed(1)
# Sample from a multivariate normal with correlation.
pcov = np.array([[0.4, 0.3, 0.5], [0.3, 0.8, 0.4], [0.5, 0.4, 1.2]])
xdata = np.random.multivariate_normal([10, 100, 70], pcov, N).T
fit = ConstrainedNumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=xdata[2],
)
fit_std = NumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=xdata[2],
)
fit_new_result = fit.execute(tol=1e-9)
std_result = fit_std.execute()
# When no errors are given, we default to `absolute_sigma=False`, since
# that is the best we can do.
self.assertFalse(fit.absolute_sigma)
# The standard method and the Constrained object called without constraints
# should give roughly the same parameter values.
self.assertAlmostEqual(fit_new_result.value(a), std_result.value(a), 3)
self.assertAlmostEqual(fit_new_result.value(b), std_result.value(b), 3)
self.assertAlmostEqual(fit_new_result.value(c), std_result.value(c), 3)
# in this toy model, fitting is identical to simply taking the average
self.assertAlmostEqual(fit_new_result.value(a), np.mean(xdata[0]), 4)
self.assertAlmostEqual(fit_new_result.value(b), np.mean(xdata[1]), 4)
self.assertAlmostEqual(fit_new_result.value(c), np.mean(xdata[2]), 4)
# Since no sigma were provided, absolute_sigma=False. Therefore the
# standard deviation doesn't match the expected value, but it does match the emperical value
self.assertAlmostEqual(
fit_new_result.stdev(a) / (np.std(xdata[0], ddof=1) / np.sqrt(N)),
1.0, 3)
self.assertAlmostEqual(
fit_new_result.stdev(b) / (np.std(xdata[1], ddof=1) / np.sqrt(N)),
1.0, 3)
self.assertAlmostEqual(
fit_new_result.stdev(c) / (np.std(xdata[2], ddof=1) / np.sqrt(N)),
1.0, 3)
# Test for a miss on the exact value
self.assertNotAlmostEqual(
fit_new_result.stdev(a) / np.sqrt(pcov[0, 0] / N), 1.0, 3)
self.assertNotAlmostEqual(
fit_new_result.stdev(b) / np.sqrt(pcov[1, 1] / N), 1.0, 3)
self.assertNotAlmostEqual(
fit_new_result.stdev(c) / np.sqrt(pcov[2, 2] / N), 1.0, 3)
# The standard object actually does not predict the right values for
# stdev, because its method for computing them apperantly does not allow
# for vector valued functions.
# So actually, for vector valued functions its better to use
# ConstrainedNumericalLeastSquares, though this does not give covariances.
# With the correct values of sigma, absolute_sigma=True should be in
# agreement with analytical.
sigmadata = np.array(
[np.sqrt(pcov[0, 0]),
np.sqrt(pcov[1, 1]),
np.sqrt(pcov[2, 2])])
fit = ConstrainedNumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=xdata[2],
sigma_a_i=sigmadata[0],
sigma_b_i=sigmadata[1],
sigma_c_i=sigmadata[2],
)
self.assertTrue(fit.absolute_sigma)
fit_result = fit.execute(tol=1e-9)
# The standard deviation in the mean is stdev/sqrt(N),
# see test_param_error_analytical
self.assertAlmostEqual(
fit_result.stdev(a) / np.sqrt(pcov[0, 0] / N), 1.0, 4)
self.assertAlmostEqual(
fit_result.stdev(b) / np.sqrt(pcov[1, 1] / N), 1.0, 4)
self.assertAlmostEqual(
fit_result.stdev(c) / np.sqrt(pcov[2, 2] / N), 1.0, 4)
# Finally, we should confirm that with unrealistic sigma and
# absolute_sigma=True, we are no longer in agreement with the analytical result
# Let's take everything to be 1 to point out the dangers of doing so.
sigmadata = np.array([1, 1, 1])
fit2 = ConstrainedNumericalLeastSquares(model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=xdata[2],
sigma_a_i=sigmadata[0],
sigma_b_i=sigmadata[1],
sigma_c_i=sigmadata[2],
absolute_sigma=True)
fit_result = fit2.execute(tol=1e-9)
# Should be off bigly
self.assertNotAlmostEqual(
fit_result.stdev(a) / np.sqrt(pcov[0, 0] / N), 1.0, 1)
self.assertNotAlmostEqual(
fit_result.stdev(b) / np.sqrt(pcov[1, 1] / N), 1.0, 1)
self.assertNotAlmostEqual(
fit_result.stdev(c) / np.sqrt(pcov[2, 2] / N), 1.0, 1)
def test_vector_parameter_error(self):
"""
Tests `ConstrainedNumericalLeastSquares` parameter error estimation with
vector models. This is done by using the typical angles of a triangle
example. For completeness, we throw in covariance between the angles.
As it stands now, `ConstrainedNumericalLeastSquares` is able to correctly
predict the values of the parameters an their standard deviations, but
it is not able to give the covariances. Those are therefore returned as
nan, to prevent people from citing them as 0.0.
"""
N = 10000
a, b, c = parameters('a, b, c')
a_i, b_i, c_i = variables('a_i, b_i, c_i')
model = {a_i: a, b_i: b, c_i: c}
np.random.seed(1)
# Sample from a multivariate normal with correlation.
pcov = np.array([[0.4, 0.3, 0.5], [0.3, 0.8, 0.4], [0.5, 0.4, 1.2]])
xdata = np.random.multivariate_normal([10, 100, 70], pcov, N).T
fit = ConstrainedNumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=xdata[2],
)
fit_std = NumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=xdata[2],
)
fit_new_result = fit.execute(tol=1e-9)
std_result = fit_std.execute()
# When no errors are given, we default to `absolute_sigma=False`, since
# that is the best we can do.
self.assertFalse(fit.absolute_sigma)
# The standard method and the Constrained object called without constraints
# should give roughly the same parameter values.
self.assertAlmostEqual(fit_new_result.value(a), std_result.value(a), 3)
self.assertAlmostEqual(fit_new_result.value(b), std_result.value(b), 3)
self.assertAlmostEqual(fit_new_result.value(c), std_result.value(c), 3)
# in this toy model, fitting is identical to simply taking the average
self.assertAlmostEqual(fit_new_result.value(a), np.mean(xdata[0]), 4)
self.assertAlmostEqual(fit_new_result.value(b), np.mean(xdata[1]), 4)
self.assertAlmostEqual(fit_new_result.value(c), np.mean(xdata[2]), 4)
# Since no sigma were provided, absolute_sigma=False. Therefore the
# standard deviation doesn't match the expected value, but it does match the emperical value
self.assertAlmostEqual(fit_new_result.stdev(a)/(np.std(xdata[0], ddof=1)/np.sqrt(N)), 1.0, 3)
self.assertAlmostEqual(fit_new_result.stdev(b)/(np.std(xdata[1], ddof=1)/np.sqrt(N)), 1.0, 3)
self.assertAlmostEqual(fit_new_result.stdev(c)/(np.std(xdata[2], ddof=1)/np.sqrt(N)), 1.0, 3)
# Test for a miss on the exact value
self.assertNotAlmostEqual(fit_new_result.stdev(a)/np.sqrt(pcov[0, 0]/N), 1.0, 3)
self.assertNotAlmostEqual(fit_new_result.stdev(b)/np.sqrt(pcov[1, 1]/N), 1.0, 3)
self.assertNotAlmostEqual(fit_new_result.stdev(c)/np.sqrt(pcov[2, 2]/N), 1.0, 3)
# The standard object actually does not predict the right values for
# stdev, because its method for computing them apperantly does not allow
# for vector valued functions.
# So actually, for vector valued functions its better to use
# ConstrainedNumericalLeastSquares, though this does not give covariances.
# With the correct values of sigma, absolute_sigma=True should be in
# agreement with analytical.
sigmadata = np.array([
np.sqrt(pcov[0, 0]),
np.sqrt(pcov[1, 1]),
np.sqrt(pcov[2, 2])
])
fit = ConstrainedNumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=xdata[2],
sigma_a_i=sigmadata[0],
sigma_b_i=sigmadata[1],
sigma_c_i=sigmadata[2],
)
self.assertTrue(fit.absolute_sigma)
fit_result = fit.execute(tol=1e-9)
# The standard deviation in the mean is stdev/sqrt(N),
# see test_param_error_analytical
self.assertAlmostEqual(fit_result.stdev(a)/np.sqrt(pcov[0, 0]/N), 1.0, 4)
self.assertAlmostEqual(fit_result.stdev(b)/np.sqrt(pcov[1, 1]/N), 1.0, 4)
self.assertAlmostEqual(fit_result.stdev(c)/np.sqrt(pcov[2, 2]/N), 1.0, 4)
# Finally, we should confirm that with unrealistic sigma and
# absolute_sigma=True, we are no longer in agreement with the analytical result
# Let's take everything to be 1 to point out the dangers of doing so.
sigmadata = np.array([1, 1, 1])
fit2 = ConstrainedNumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=xdata[2],
sigma_a_i=sigmadata[0],
sigma_b_i=sigmadata[1],
sigma_c_i=sigmadata[2],
absolute_sigma=True
)
fit_result = fit2.execute(tol=1e-9)
# Should be off bigly
self.assertNotAlmostEqual(fit_result.stdev(a)/np.sqrt(pcov[0, 0]/N), 1.0, 1)
self.assertNotAlmostEqual(fit_result.stdev(b)/np.sqrt(pcov[1, 1]/N), 1.0, 1)
self.assertNotAlmostEqual(fit_result.stdev(c)/np.sqrt(pcov[2, 2]/N), 1.0, 1)
def test_vector_constrained_fitting(self):
"""
Tests `ConstrainedNumericalLeastSquares` with vector models. The
classical example of fitting measurements of the angles of a triangle is
taken. In this case we know they should add up to 180 degrees, so this
can be added as a constraint. Additionally, not even all three angles
have to be provided with measurement data since the constrained means
the angles are not independent.
"""
a, b, c = parameters('a, b, c')
a_i, b_i, c_i = variables('a_i, b_i, c_i')
model = {a_i: a, b_i: b, c_i: c}
xdata = np.array([
[10.1, 9., 10.5, 11.2, 9.5, 9.6, 10.],
[102.1, 101., 100.4, 100.8, 99.2, 100., 100.8],
[71.6, 73.2, 69.5, 70.2, 70.8, 70.6, 70.1],
])
fit_none = ConstrainedNumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=None,
)
fit = ConstrainedNumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=xdata[2],
)
fit_std = NumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=xdata[2],
)
fit_constrained = ConstrainedNumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=xdata[2],
constraints=[Equality(a + b + c, 180)]
)
fit_none_result = fit_none.execute()
fit_new_result = fit.execute()
std_result = fit_std.execute()
constr_result = fit_constrained.execute()
# The total of averages should equal the total of the params by definition
mean_total = np.mean(np.sum(xdata, axis=0))
params_tot = std_result.value(a) + std_result.value(b) + std_result.value(c)
self.assertAlmostEqual(mean_total, params_tot, 4)
# The total after constraining to 180 should be exactly 180.
params_tot = constr_result.value(a) + constr_result.value(b) + constr_result.value(c)
self.assertAlmostEqual(180.0, params_tot, 4)
# The standard method and the Constrained object called without constraints
# should behave roughly the same.
self.assertAlmostEqual(fit_new_result.value(a), std_result.value(a), 4)
self.assertAlmostEqual(fit_new_result.value(b), std_result.value(b), 4)
self.assertAlmostEqual(fit_new_result.value(c), std_result.value(c), 4)
# When fitting with a dataset set to None, for this example the value of c
# should be unaffected.
self.assertAlmostEqual(fit_none_result.value(a), std_result.value(a), 4)
self.assertAlmostEqual(fit_none_result.value(b), std_result.value(b), 4)
self.assertAlmostEqual(fit_none_result.value(c), c.value)
fit_none_constr = ConstrainedNumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=None,
constraints=[Equality(a + b + c, 180)]
)
none_constr_result = fit_none_constr.execute()
params_tot = none_constr_result.value(a) + none_constr_result.value(b) + none_constr_result.value(c)
self.assertAlmostEqual(180.0, params_tot, 4)
def test_vector_constrained_fitting(self):
"""
Tests `ConstrainedNumericalLeastSquares` with vector models. The
classical example of fitting measurements of the angles of a triangle is
taken. In this case we know they should add up to 180 degrees, so this
can be added as a constraint. Additionally, not even all three angles
have to be provided with measurement data since the constrained means
the angles are not independent.
"""
a, b, c = parameters('a, b, c')
a_i, b_i, c_i = variables('a_i, b_i, c_i')
model = {a_i: a, b_i: b, c_i: c}
xdata = np.array([
[10.1, 9., 10.5, 11.2, 9.5, 9.6, 10.],
[102.1, 101., 100.4, 100.8, 99.2, 100., 100.8],
[71.6, 73.2, 69.5, 70.2, 70.8, 70.6, 70.1],
])
fit_none = ConstrainedNumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=None,
)
fit = ConstrainedNumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=xdata[2],
)
fit_std = NumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=xdata[2],
)
fit_constrained = ConstrainedNumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=xdata[2],
constraints=[Equality(a + b + c, 180)])
fit_none_result = fit_none.execute()
fit_new_result = fit.execute()
std_result = fit_std.execute()
constr_result = fit_constrained.execute()
# The total of averages should equal the total of the params by definition
mean_total = np.mean(np.sum(xdata, axis=0))
params_tot = std_result.value(a) + std_result.value(
b) + std_result.value(c)
self.assertAlmostEqual(mean_total, params_tot, 4)
# The total after constraining to 180 should be exactly 180.
params_tot = constr_result.value(a) + constr_result.value(
b) + constr_result.value(c)
self.assertAlmostEqual(180.0, params_tot, 4)
# The standard method and the Constrained object called without constraints
# should behave roughly the same.
self.assertAlmostEqual(fit_new_result.value(a), std_result.value(a), 4)
self.assertAlmostEqual(fit_new_result.value(b), std_result.value(b), 4)
self.assertAlmostEqual(fit_new_result.value(c), std_result.value(c), 4)
# When fitting with a dataset set to None, for this example the value of c
# should be unaffected.
self.assertAlmostEqual(fit_none_result.value(a), std_result.value(a),
4)
self.assertAlmostEqual(fit_none_result.value(b), std_result.value(b),
4)
self.assertAlmostEqual(fit_none_result.value(c), c.value)
fit_none_constr = ConstrainedNumericalLeastSquares(
model=model,
a_i=xdata[0],
b_i=xdata[1],
c_i=None,
constraints=[Equality(a + b + c, 180)])
none_constr_result = fit_none_constr.execute()
params_tot = none_constr_result.value(a) + none_constr_result.value(
b) + none_constr_result.value(c)
self.assertAlmostEqual(180.0, params_tot, 4)
def test_straight_line_analytical(self):
"""
Test symfit against a straight line, for which the parameters and their
uncertainties are known analytically. Assuming equal weights.
"""
data = [[0, 1], [1, 0], [3, 2], [5, 4]]
xdata, ydata = (np.array(i, dtype='float64') for i in zip(*data))
# x = np.arange(0, 100, 0.1)
# np.random.seed(10)
# y = 3.0*x + 105.0 + np.random.normal(size=x.shape)
dx = xdata - xdata.mean()
dy = ydata - ydata.mean()
mean_squared_x = np.mean(xdata**2) - np.mean(xdata)**2
mean_xy = np.mean(xdata * ydata) - np.mean(xdata) * np.mean(ydata)
a = mean_xy / mean_squared_x
b = ydata.mean() - a * xdata.mean()
self.assertAlmostEqual(a, 0.694915, 6) # values from Mathematica
self.assertAlmostEqual(b, 0.186441, 6)
S = np.sum((ydata - (a * xdata + b))**2)
var_a_exact = S / (len(xdata) * (len(xdata) - 2) * mean_squared_x)
var_b_exact = var_a_exact * np.mean(xdata**2)
a_exact = a
b_exact = b
# We will now compare these exact results with values from symfit, numerically
a, b = parameters('a, b')
x, y = variables('x, y')
model = {y: a * x + b}
fit = NumericalLeastSquares(model, x=xdata,
y=ydata) #, absolute_sigma=False)
fit_result = fit.execute()
popt, pcov = curve_fit(lambda z, c, d: c * z + d,
xdata,
ydata,
jac=lambda z, c, d: np.transpose(
[xdata, np.ones_like(xdata)]))
# jac=lambda p, x, y, func: np.transpose([x, np.ones_like(x)]))
# Dfun=lambda p, x, y, func: print(p, func, x, y))
# curve_fit
self.assertAlmostEqual(a_exact, popt[0], 4)
self.assertAlmostEqual(b_exact, popt[1], 4)
self.assertAlmostEqual(var_a_exact, pcov[0][0], 6)
self.assertAlmostEqual(var_b_exact, pcov[1][1], 6)
self.assertAlmostEqual(a_exact, fit_result.value(a), 4)
self.assertAlmostEqual(b_exact, fit_result.value(b), 4)
self.assertAlmostEqual(var_a_exact, fit_result.variance(a), 6)
self.assertAlmostEqual(var_b_exact, fit_result.variance(b), 6)
# Do the fit with the LinearLeastSquares object
fit = LinearLeastSquares(model, x=xdata, y=ydata)
fit_result = fit.execute()
self.assertAlmostEqual(a_exact, fit_result.value(a), 4)
self.assertAlmostEqual(b_exact, fit_result.value(b), 4)
self.assertAlmostEqual(var_a_exact, fit_result.variance(a), 6)
self.assertAlmostEqual(var_b_exact, fit_result.variance(b), 6)
# Lets also make sure the entire covariance matrix is the same
for cov1, cov2 in zip(fit_result.covariance_matrix.flatten(),
pcov.flatten()):
self.assertAlmostEqual(cov1, cov2)
def test_backwards_compatibility(self):
"""
The LinearLeastSquares should give results compatible with the NumericalLeastSquare's
and curve_fit. To do this I test here the simple analytical model also used to calibrate
the definition of absolute_sigma.
"""
N = 1000
sigma = 31.4 * np.ones(N)
xn = np.arange(N, dtype=np.float)
yn = np.zeros_like(xn)
np.random.seed(10)
yn = yn + np.random.normal(size=len(yn), scale=sigma)
a = Parameter()
y = Variable()
model = {y: a}
fit = LinearLeastSquares(model,
y=yn,
sigma_y=sigma,
absolute_sigma=False)
fit_result = fit.execute()
fit = NumericalLeastSquares(model,
y=yn,
sigma_y=sigma,
absolute_sigma=False)
num_result = fit.execute()
popt, pcov = curve_fit(lambda x, a: a * np.ones_like(x),
xn,
yn,
sigma=sigma,
absolute_sigma=False)
self.assertAlmostEqual(fit_result.value(a), num_result.value(a))
self.assertAlmostEqual(fit_result.stdev(a), num_result.stdev(a))
self.assertAlmostEqual(fit_result.value(a), popt[0], 5)
self.assertAlmostEqual(fit_result.stdev(a), pcov[0, 0]**0.5, 5)
fit = LinearLeastSquares(model,
y=yn,
sigma_y=sigma,
absolute_sigma=True)
fit_result = fit.execute()
fit = NumericalLeastSquares(model,
y=yn,
sigma_y=sigma,
absolute_sigma=True)
num_result = fit.execute()
popt, pcov = curve_fit(lambda x, a: a * np.ones_like(x),
xn,
yn,
sigma=sigma,
absolute_sigma=True)
self.assertAlmostEqual(fit_result.value(a), num_result.value(a))
self.assertAlmostEqual(fit_result.stdev(a), num_result.stdev(a))
self.assertAlmostEqual(fit_result.value(a), popt[0], 5)
self.assertAlmostEqual(fit_result.stdev(a), pcov[0, 0]**0.5, 5)
def test_weights(self):
"""
Compare NumericalLeastSquares with LinearLeastSquares to see if errors
are implemented consistently.
"""
from symfit import Variable, Parameter, Fit
t_data = np.array([1.4, 2.1, 2.6, 3.0, 3.3])
y_data = np.array([10, 20, 30, 40, 50])
sigma = 0.2
n = np.array([5, 3, 8, 15, 30])
sigma_t = sigma / np.sqrt(n)
# We now define our model
t, y = variables('t, y')
b = Parameter()
sqrt_g_inv = Parameter(
) # sqrt_g_inv = sqrt(1/g). Currently needed to linearize.
# t_model = (2 * y / g)**0.5
t_model = {t: 2 * y**0.5 * sqrt_g_inv + b}
# Different sigma for every point
fit = NumericalLeastSquares(t_model,
y=y_data,
t=t_data,
sigma_t=sigma_t,
absolute_sigma=False)
num_result_rel = fit.execute()
fit = NumericalLeastSquares(t_model,
y=y_data,
t=t_data,
sigma_t=sigma_t,
absolute_sigma=True)
num_result = fit.execute()
# cov matrix should now be different
for cov1, cov2 in zip(num_result_rel.covariance_matrix.flatten(),
num_result.covariance_matrix.flatten()):
# Make the absolute cov relative to see if it worked.
ss_res = np.sum(num_result_rel.infodict['fvec']**2)
degrees_of_freedom = len(
fit.data[fit.model.dependent_vars[0].name]) - len(
fit.model.params)
s_sq = ss_res / degrees_of_freedom
self.assertAlmostEqual(cov1, cov2 * s_sq)
# print(fit.model.numerical_chi_jacobian[0](sqrt_g_inv=1, **fit.data))
fit = LinearLeastSquares(t_model, y=y_data, t=t_data, sigma_t=sigma_t)
fit_result = fit.execute()
self.assertAlmostEqual(num_result.value(sqrt_g_inv),
fit_result.value(sqrt_g_inv))
self.assertAlmostEqual(num_result.value(b), fit_result.value(b))
# for cov1, cov2 in zip(num_result.params.covariance_matrix.flatten(), fit_result.params.covariance_matrix.flatten()):
# self.assertAlmostEqual(cov1, cov2)
# print(cov1, cov2)
for cov1, cov2 in zip(num_result.covariance_matrix.flatten(),
fit_result.covariance_matrix.flatten()):
self.assertAlmostEqual(cov1, cov2)
import numpy as np
from symfit.contrib.interactive_guess import InteractiveGuess2D
# First order reaction kinetics. Data taken from http://chem.libretexts.org/Core/Physical_Chemistry/Kinetics/Rate_Laws/The_Rate_Law
tdata = np.array([0, 0.9184, 9.0875, 11.2485, 17.5255, 23.9993, 27.7949,
31.9783, 35.2118, 42.973, 46.6555, 50.3922, 55.4747, 61.827,
65.6603, 70.0939])
concentration_A = np.array([0.906, 0.8739, 0.5622, 0.5156, 0.3718, 0.2702, 0.2238,
0.1761, 0.1495, 0.1029, 0.086, 0.0697, 0.0546, 0.0393,
0.0324, 0.026])
concentration_B = np.max(concentration_A) - concentration_A
# Define our ODE model
A, B, t = variables('A, B, t')
k = Parameter()
model_dict = {
D(A, t): - k * A**2,
D(B, t): k * A**2
}
model = ODEModel(model_dict, initial={t: tdata[0], A: concentration_A[0], B: 0})
guess = InteractiveGuess2D(model, A=concentration_A, B=concentration_B, t=tdata, n_points=250)
guess.execute()
print(guess)
fit = NumericalLeastSquares(model, A=concentration_A, B=concentration_B, t=tdata)
fit_result = fit.execute()
print(fit_result)
