def test_xerr(self):
c = Parameter(1.0, name='c')
m = Parameter(2.0, name='m')
p = c | m
fit_model = Model(p, fitfunc=line3)
assert_(fit_model._fitfunc_has_xerr is True)
fit_model = Model(p, fitfunc=line2)
assert_(fit_model._fitfunc_has_xerr is False)
def test_xerr(self):
c = Parameter(1.0, name="c")
m = Parameter(2.0, name="m")
p = c | m
fit_model = Model(p, fitfunc=line3)
assert fit_model._fitfunc_has_xerr is True
fit_model = Model(p, fitfunc=line2)
assert fit_model._fitfunc_has_xerr is False
def test_evaluation(self):
c = Parameter(1.0, name="c")
m = Parameter(2.0, name="m")
p = c | m
fit_model = Model(p, fitfunc=line)
x = np.linspace(0, 100.0, 20)
y = 2.0 * x + 1.0
# different ways of getting the model instance to evaluate
assert_equal(fit_model.model(x, p), y)
assert_equal(fit_model(x, p), y)
assert_equal(fit_model.model(x), y)
assert_equal(fit_model(x), y)
# can we pickle the model object
pkl = pickle.dumps(fit_model)
unpkl = pickle.loads(pkl)
assert_equal(unpkl(x), y)
# you should be able to use a lambda
fit_model = Model(p, fitfunc=line2)
assert_equal(fit_model(x, p), y)
# and swap the order of parameters - retrieve by key
p = m | c
fit_model = Model(p, fitfunc=line2)
assert_equal(fit_model(x, p), y)
def setup(self):
# Reproducible results!
np.random.seed(123)
m_true = -0.9594
b_true = 4.294
f_true = 0.534
m_ls = -1.1040757010910947
b_ls = 5.4405552502319505
# Generate some synthetic data from the model.
N = 50
x = np.sort(10 * np.random.rand(N))
y_err = 0.1 + 0.5 * np.random.rand(N)
y = m_true * x + b_true
y += np.abs(f_true * y) * np.random.randn(N)
y += y_err * np.random.randn(N)
data = Data1D(data=(x, y, y_err))
p = Parameter(b_ls, 'b', vary=True, bounds=(-100, 100))
p |= Parameter(m_ls, 'm', vary=True, bounds=(-100, 100))
model = Model(p, fitfunc=line)
self.objective = Objective(model, data)
self.mcfitter = CurveFitter(self.objective)
self.mcfitter_t = CurveFitter(self.objective, ntemps=20)
self.mcfitter.initialise('prior')
self.mcfitter_t.initialise('prior')
def NIST_runner(
dataset,
method="least_squares",
chi_atol=1e-5,
val_rtol=1e-2,
err_rtol=6e-3,
):
NIST_dataset = ReadNistData(dataset)
x, y = (NIST_dataset["x"], NIST_dataset["y"])
if dataset == "Nelson":
y = np.log(y)
params = NIST_dataset["start"]
fitfunc = NIST_Models[dataset][0]
model = Model(params, fitfunc)
objective = Objective(model, (x, y))
fitter = CurveFitter(objective)
result = fitter.fit(method=method)
assert_allclose(objective.chisqr(),
NIST_dataset["sum_squares"],
atol=chi_atol)
certval = NIST_dataset["cert_values"]
assert_allclose(result.x, certval, rtol=val_rtol)
if "stderr" in result:
certerr = NIST_dataset["cert_stderr"]
assert_allclose(result.stderr, certerr, rtol=err_rtol)
def test_ND_model(self):
# Check that ND data can be passed to/from a model
# Here we see if x can be multidimensional, and that y can return
# multidimensional data.
# It should be up to the user to ensure that the Data/Model/Objective
# stack is returning something consistent with each other.
# e.g. the Model output should return something with the same shape as
# Data.y.
rng = np.random.default_rng()
x = rng.uniform(size=100).reshape(2, 50)
c = Parameter(1.0, name="c")
m = Parameter(2.0, name="m")
p = c | m
# check that the function is returning what it's supposed to before
# we test Model
y0 = line(x[0], p)
y1 = line(x[1], p)
desired = np.vstack((y0, y1))
assert_allclose(line_ND(x, p), desired)
fit_model = Model(p, fitfunc=line_ND)
y = fit_model(x)
assert_allclose(y, desired)
def NIST_runner(dataset, method='least_squares', chi_atol=1e-5,
val_rtol=1e-2, err_rtol=5e-3):
NIST_dataset = ReadNistData(dataset)
x, y = (NIST_dataset['x'], NIST_dataset['y'])
if dataset == 'Nelson':
y = np.log(y)
params = NIST_dataset['start']
fitfunc = NIST_Models[dataset][0]
model = Model(params, fitfunc)
objective = Objective(model, (x, y))
fitter = CurveFitter(objective)
result = fitter.fit(method=method)
assert_allclose(objective.chisqr(),
NIST_dataset['sum_squares'],
atol=chi_atol)
certval = NIST_dataset['cert_values']
assert_allclose(result.x, certval, rtol=val_rtol)
if 'stderr' in result:
certerr = NIST_dataset['cert_stderr']
assert_allclose(result.stderr, certerr, rtol=err_rtol)
def setup_method(self, tmpdir):
self.path = os.path.dirname(os.path.abspath(__file__))
self.tmpdir = tmpdir.strpath
theoretical = np.loadtxt(os.path.join(self.path, "gauss_data.txt"))
xvals, yvals, evals = np.hsplit(theoretical, 3)
xvals = xvals.flatten()
yvals = yvals.flatten()
evals = evals.flatten()
# these best weighted values and uncertainties obtained with Igor
self.best_weighted = [-0.00246095, 19.5299, -8.28446e-2, 1.24692]
self.best_weighted_errors = [
0.0220313708486,
1.12879436221,
0.0447659158681,
0.0412022938883,
]
self.best_weighted_chisqr = 77.6040960351
self.best_unweighted = [
-0.10584111872702096,
19.240347049328989,
0.0092623066070940396,
1.501362314145845,
]
self.best_unweighted_errors = [
0.34246565477,
0.689820935208,
0.0411243173041,
0.0693429375282,
]
self.best_unweighted_chisqr = 497.102084956
self.p0 = np.array([0.1, 20.0, 0.1, 0.1])
self.names = ["bkg", "A", "x0", "width"]
self.bounds = [(-1, 1), (0, 30), (-5.0, 5.0), (0.001, 2)]
self.params = Parameters(name="gauss_params")
for p, name, bound in zip(self.p0, self.names, self.bounds):
param = Parameter(p, name=name)
param.range(*bound)
param.vary = True
self.params.append(param)
self.model = Model(self.params, fitfunc=gauss)
self.data = Data1D((xvals, yvals, evals))
self.objective = Objective(self.model, self.data)
return 0
def setup_method(self):
# Choose the "true" parameters.
# Reproducible results!
np.random.seed(123)
self.m_true = -0.9594
self.b_true = 4.294
self.f_true = 0.534
self.m_ls = -1.1040757010910947
self.b_ls = 5.4405552502319505
# Generate some synthetic data from the model.
N = 50
x = np.sort(10 * np.random.rand(N))
y_err = 0.1 + 0.5 * np.random.rand(N)
y = self.m_true * x + self.b_true
y += np.abs(self.f_true * y) * np.random.randn(N)
y += y_err * np.random.randn(N)
self.data = Data1D(data=(x, y, y_err))
self.p = Parameter(self.b_ls, 'b') | Parameter(self.m_ls, 'm')
self.model = Model(self.p, fitfunc=line)
self.objective = Objective(self.model, self.data)
# want b and m
self.p[0].vary = True
self.p[1].vary = True
mod = np.array([4.78166609, 4.42364699, 4.16404064, 3.50343504,
3.4257084, 2.93594347, 2.92035638, 2.67533842,
2.28136038, 2.19772983, 1.99295496, 1.93748334,
1.87484436, 1.65161016, 1.44613461, 1.11128101,
1.04584535, 0.86055984, 0.76913963, 0.73906649,
0.73331407, 0.68350418, 0.65216599, 0.59838566,
0.13070299, 0.10749131, -0.01010195, -0.10010155,
-0.29495372, -0.42817431, -0.43122391, -0.64637715,
-1.30560686, -1.32626428, -1.44835768, -1.52589881,
-1.56371158, -2.12048349, -2.24899179, -2.50292682,
-2.53576659, -2.55797996, -2.60870542, -2.7074727,
-3.93781479, -4.12415366, -4.42313742, -4.98368609,
-5.38782395, -5.44077086])
self.mod = mod
def test_multidimensionality(self):
# Check that ND data can be used with an objective/model/data
# (or at least it doesn't stand in the way)
rng = np.random.default_rng()
x = rng.uniform(size=100).reshape(50, 2)
desired = line_ND(x, self.p)
assert desired.shape == (50, 2)
data = Data1D((x, desired))
model = Model(self.p, fitfunc=line_ND)
y = model(x)
assert_allclose(y, desired)
objective = Objective(model, data)
assert_allclose(objective.chisqr(), 0)
assert_allclose(objective.generative(), desired)
assert_allclose(objective.residuals(), 0)
assert objective.residuals().shape == (50, 2)
objective.logl()
objective.logpost()
covar = objective.covar()
assert covar.shape == (2, 2)
def test_covar(self):
# checks objective.covar against optimize.least_squares covariance.
path = os.path.dirname(os.path.abspath(__file__))
theoretical = np.loadtxt(os.path.join(path, 'gauss_data.txt'))
xvals, yvals, evals = np.hsplit(theoretical, 3)
xvals = xvals.flatten()
yvals = yvals.flatten()
evals = evals.flatten()
p0 = np.array([0.1, 20., 0.1, 0.1])
names = ['bkg', 'A', 'x0', 'width']
bounds = [(-1, 1), (0, 30), (-5., 5.), (0.001, 2)]
params = Parameters(name="gauss_params")
for p, name, bound in zip(p0, names, bounds):
param = Parameter(p, name=name)
param.range(*bound)
param.vary = True
params.append(param)
model = Model(params, fitfunc=gauss)
data = Data1D((xvals, yvals, evals))
objective = Objective(model, data)
# first calculate least_squares jac/hess/covariance matrices
res = least_squares(objective.residuals,
np.array(params),
jac='3-point')
hess_least_squares = np.matmul(res.jac.T, res.jac)
covar_least_squares = np.linalg.inv(hess_least_squares)
# now calculate corresponding matrices by hand, to see if the approach
# concurs with least_squares
objective.setp(res.x)
_pvals = np.array(res.x)
def residuals_scaler(vals):
return np.squeeze(objective.residuals(_pvals * vals))
jac = approx_derivative(residuals_scaler, np.ones_like(_pvals))
hess = np.matmul(jac.T, jac)
covar = np.linalg.inv(hess)
covar = covar * np.atleast_2d(_pvals) * np.atleast_2d(_pvals).T
assert_allclose(covar, covar_least_squares)
# check that objective.covar corresponds to the least_squares
# covariance matrix
objective.setp(res.x)
_pvals = np.array(res.x)
covar_objective = objective.covar()
assert_allclose(covar_objective, covar_least_squares)
# now see what happens with a parameter that has no effect on residuals
param = Parameter(1.234, name='dummy')
param.vary = True
params.append(param)
from pytest import raises
with raises(LinAlgError):
objective.covar()