def testNoneParameters(self):
if IGNORE_TEST:
return
self._init()
fitter = ModelFitterCore(th.ANTIMONY_MODEL, self.timeseries, None)
fitter.fitModel()
self.assertIsNone(fitter.params)
self.assertGreater(len(fitter.fittedTS), 0)
def test(method):
fitter = ModelFitterCore(th.ANTIMONY_MODEL, self.timeseries,
list(th.PARAMETER_DCT.keys()), fitterMethods=method)
fitter.fitModel()
for parameter in ["k1", "k2", "k3", "k4", "k5"]:
diff = np.abs(th.PARAMETER_DCT[parameter]
- dct[parameter])
frac = diff/dct[parameter]
self.assertLess(diff/dct[parameter], 5.0)
def calc(method, probNan=0.2):
nanTimeseries = self.timeseries.copy()
for col in self.timeseries.colnames:
for idx in range(len(nanTimeseries)):
if np.random.random() <= probNan:
nanTimeseries[col][idx] = np.nan
fitter = ModelFitterCore(th.ANTIMONY_MODEL, nanTimeseries,
list(th.PARAMETER_DCT.keys()), fitterMethods=method)
fitter.fitModel()
diff = np.abs(th.PARAMETER_DCT[PARAMETER]
- fitter.params.valuesdict()[PARAMETER])
return diff
def test(col, func, maxDifference=0.0):
timeseries = self.timeseries.copy()
timeseries[col] = func(timeseries)
fittedDataTransformDct = {col: func}
fitter = ModelFitterCore(th.ANTIMONY_MODEL, timeseries,
list(th.PARAMETER_DCT.keys()),
fittedDataTransformDct=fittedDataTransformDct)
fitter.fitModel()
for name in self.fitter.params.valuesdict().keys():
value1 = self.fitter.params.valuesdict()[name]
value2 = fitter.params.valuesdict()[name]
diff = np.abs(value1-value2)
self.assertLessEqual(diff, maxDifference)
def test(method):
compareDct = {}
for numFitRepeat in NUM_FIT_REPEATS:
fitter = ModelFitterCore(th.ANTIMONY_MODEL, self.timeseries,
list(th.PARAMETER_DCT.keys()), fitterMethods=method,
numFitRepeat=numFitRepeat)
fitter.fitModel()
compareDct[numFitRepeat] = self.checkParameterValues()
for parameter in ["k1", "k2", "k3", "k4", "k5"]:
first = NUM_FIT_REPEATS[0]
last = NUM_FIT_REPEATS[1]
self.assertLessEqual(compareDct[first][parameter],
compareDct[last][parameter])
def testGetFittedModel(self):
if IGNORE_TEST:
return
self._init()
fitter1 = ModelFitterCore(th.ANTIMONY_MODEL, self.timeseries,
list(th.PARAMETER_DCT.keys()))
fitter1.fitModel()
fittedModel = fitter1.getFittedModel()
fitter2 = ModelFitterCore(fittedModel, self.timeseries,
list(th.PARAMETER_DCT.keys()))
fitter2.fitModel()
# Should get same fit without changing the parameters
std1 = np.var(fitter1.residualsTS.flatten())
std2 = np.var(fitter2.residualsTS.flatten())
if tcn.IGNORE_ACCURACY:
return
self.assertTrue(np.isclose(std1, std2, rtol=0.1))
class ModelFitterWrapper(AbstractFitter):
def __init__(self, modelSpecification, observedTS, parametersToFit,
trainIdxs=None, testIdxs=None, **kwargs):
"""
Parameters
----------
modelSpecification: str
antimony model
observedTS: NamedTimeseries
parametersToFit: list-str/SBstoat.Parameter/None
parameters in the model that you want to fit
if None, no parameters are fit
trainIdxs: list-int
rows of observedData used for estimating parameters
testIdxs: list-int
rows of observedData used for scoring fit
"""
super().__init__()
self.trainIdxs = trainIdxs
self.testIdxs = testIdxs
self.observedTS = observedTS
if self.trainIdxs is None:
self.trainIdxs = list(range(len(self.observedTS)))
if self.testIdxs is None:
self.testIdxs = list(range(len(self.observedTS)))
self.trainTS = observedTS[self.trainIdxs]
self.testTS = observedTS[self.testIdxs]
self.modelFitter = ModelFitterCore(modelSpecification, self.trainTS,
parametersToFit, **kwargs)
self.columns = self.modelFitter.selectedColumns
self.testObservedArr = self.testTS[self.columns]
@property
def parameters(self):
"""
Returns
-------
lmfit.Parameters
"""
return self.modelFitter.params
def fit(self):
"""
Estimates parameters.
Parameters
----------
Returns
-------
"""
self.modelFitter.fitModel()
def score(self):
"""
Returns an R^2 for predicting testData
Parameters
----------
Returns
-------
float
"""
fullFittedTS = self.modelFitter.runSimulation(
parameters=self.modelFitter.params,
modelSpecification=self.modelFitter.modelSpecification,
endTime=self.observedTS.end,
numPoint=len(self.observedTS),
_logger=self.modelFitter.logger,
_loggerPrefix=self.modelFitter._loggerPrefix,
)
testFittedArr = fullFittedTS[self.modelFitter.selectedColumns]
testFittedArr = testFittedArr[self.testIdxs, :]
residualsArr = self.testObservedArr - testFittedArr
rsq = 1 - np.var(residualsArr.flatten()) \
/ np.var(self.testObservedArr.flatten())
return rsq
