def eval_pmc_pfuncs(self, ):
aeval = Interpreter()
if config.models['use_old_model']:
aeval.symtable['p'] = self.params
else:
aeval.symtable['r'] = self.params
for i in range(0, self.state_count):
self.init_eval[i] = aeval.run(self.init_ast_pfuncs[i])
for i in range(0, self.state_count):
for j in range(0, self.state_count):
self.trans_eval[i][j] = aeval.run(self.trans_ast_pfuncs[i][j])
def eval_bscc_pfuncs(self, ):
aeval = Interpreter()
if config.models['use_old_model']:
aeval.symtable['p'] = self.params
else:
aeval.symtable['r'] = self.params
return [aeval.run(f) for f in self.bscc_ast_pfuncs]
def _objective_function(self, x):
"""
Abstract Objective Function Call
:param x: Input Variable
:return: Function Value of Objective
"""
aeval = Interpreter()
exprc = aeval.parse(self.objective)
aeval.symtable['x'] = x
return aeval.run(exprc)
def test_bscc_eval(parser):
parser.process()
bscc_ast_pfuncs = parser.bscc_ast_pfuncs
bscc_str_pfuncs = parser.bscc_str_pfuncs
assert len(bscc_ast_pfuncs) != 0
assert len(bscc_str_pfuncs) != 0
for f in bscc_str_pfuncs:
assert f is not None
assert len(f) != 0
r = [0.11, 0.22, 0.33]
aeval = Interpreter()
aeval.symtable['r'] = r
eval_bscc = [aeval.run(f) for f in bscc_ast_pfuncs]
assert not np.isnan(np.sum(eval_bscc))
class ExpressionModel(Model):
idvar_missing = "No independent variable found in\n %s"
idvar_notfound = "Cannot find independent variables '%s' in\n %s"
no_prefix = "ExpressionModel does not support `prefix` argument"
def __init__(self,
expr,
independent_vars=None,
init_script=None,
nan_policy='raise',
**kws):
"""Generate a model from user-supplied expression.
Parameters
----------
expr : str
Mathematical expression for model.
independent_vars : list of str or None, optional
Variable names to use as independent variables.
init_script : str or None, optional
Initial script to run in asteval interpreter.
nan_policy : str, optional
How to handle NaN and missing values in data. Must be one of:
'raise' (default), 'propagate', or 'omit'. See Notes below.
missing : str, optional
Synonym for 'nan_policy' for backward compatibility.
**kws : optional
Keyword arguments to pass to :class:`Model`.
Notes
-----
1. each instance of ExpressionModel will create and using its own
version of an asteval interpreter.
2. prefix is **not supported** for ExpressionModel.
3. nan_policy sets what to do when a NaN or missing value is seen in
the data. Should be one of:
- 'raise' : Raise a ValueError (default)
- 'propagate' : do nothing
- 'omit' : (was 'drop') drop missing data
4. The `missing` argument is deprecated in lmfit 0.9.8 and will be
removed in a later version. Use `nan_policy` instead, as it is
consistent with the Minimizer class.
"""
# create ast evaluator, load custom functions
self.asteval = Interpreter()
for name in lineshapes.functions:
self.asteval.symtable[name] = getattr(lineshapes, name, None)
if init_script is not None:
self.asteval.eval(init_script)
# save expr as text, parse to ast, save for later use
self.expr = expr.strip()
self.astcode = self.asteval.parse(self.expr)
# find all symbol names found in expression
sym_names = get_ast_names(self.astcode)
if independent_vars is None and 'x' in sym_names:
independent_vars = ['x']
if independent_vars is None:
raise ValueError(self.idvar_missing % (self.expr))
# determine which named symbols are parameter names,
# try to find all independent variables
idvar_found = [False] * len(independent_vars)
param_names = []
for name in sym_names:
if name in independent_vars:
idvar_found[independent_vars.index(name)] = True
elif name not in param_names and name not in self.asteval.symtable:
param_names.append(name)
# make sure we have all independent parameters
if not all(idvar_found):
lost = []
for ix, found in enumerate(idvar_found):
if not found:
lost.append(independent_vars[ix])
lost = ', '.join(lost)
raise ValueError(self.idvar_notfound % (lost, self.expr))
kws['independent_vars'] = independent_vars
if 'prefix' in kws:
raise Warning(self.no_prefix)
def _eval(**kwargs):
for name, val in kwargs.items():
self.asteval.symtable[name] = val
return self.asteval.run(self.astcode)
kws["nan_policy"] = nan_policy
super(ExpressionModel, self).__init__(_eval, **kws)
# set param names here, and other things normally
# set in _parse_params(), which will be short-circuited.
self.independent_vars = independent_vars
self._func_allargs = independent_vars + param_names
self._param_names = param_names
self._func_haskeywords = True
self.def_vals = {}
def __repr__(self):
"""TODO: docstring in magic method."""
return "<lmfit.ExpressionModel('%s')>" % (self.expr)
def _parse_params(self):
"""Over-write ExpressionModel._parse_params with `pass`.
This prevents normal parsing of function for parameter names.
"""
pass
class BaseFitter(object):
__doc__ = _COMMON_DOC + """
Parameters
----------
data : array-like
model : lmfit.Model
optional initial Model to use, maybe be set or changed later
""" + _COMMON_EXAMPLES_DOC
def __init__(self, data, model=None, **kwargs):
self._data = data
self.kwargs = kwargs
# GUI-based subclasses need a default value for the menu of models,
# and so an arbitrary default is applied here, for uniformity
# among the subclasses.
if model is None:
model = ExponentialModel
self.model = model
def _on_model_value_change(self, name, value):
self.model = value
def _on_fit_button_click(self, b):
self.fit()
def _on_guess_button_click(self, b):
self.guess()
@property
def data(self):
return self._data
@data.setter
def data(self, value):
self._data = value
@property
def model(self):
return self._model
@model.setter
def model(self, value):
if callable(value):
model = value()
else:
model = value
self._model = model
self.current_result = None
self._current_params = model.make_params()
# Use these to evaluate any Parameters that use expressions.
self.asteval = Interpreter()
self.namefinder = NameFinder()
self._finalize_model(value)
self.guess()
def _finalize_model(self, value):
# subclasses optionally override to update display here
pass
@property
def current_params(self):
"""Each time fit() is called, these will be updated to reflect
the latest best params. They will be used as the initial guess
for the next fit, unless overridden by arguments to fit()."""
return self._current_params
@current_params.setter
def current_params(self, new_params):
# Copy contents, but retain original params objects.
for name, par in new_params.items():
self._current_params[name].value = par.value
self._current_params[name].expr = par.expr
self._current_params[name].vary = par.vary
self._current_params[name].min = par.min
self._current_params[name].max = par.max
# Compute values for expression-based Parameters.
self.__assign_deps(self._current_params)
for _, par in self._current_params.items():
if par.value is None:
self.__update_paramval(self._current_params, par.name)
self._finalize_params()
def _finalize_params(self):
# subclasses can override this to pass params to display
pass
def guess(self):
count_indep_vars = len(self.model.independent_vars)
guessing_successful = True
try:
if count_indep_vars == 0:
guess = self.model.guess(self._data)
elif count_indep_vars == 1:
key = self.model.independent_vars[0]
val = self.kwargs[key]
d = {key: val}
guess = self.model.guess(self._data, **d)
self.current_params = guess
except NotImplementedError:
guessing_successful = False
return guessing_successful
def __assign_deps(self, params):
# N.B. This does not use self.current_params but rather
# new Parameters that are being built by self.guess().
for name, par in params.items():
if par.expr is not None:
par.ast = self.asteval.parse(par.expr)
check_ast_errors(self.asteval.error)
par.deps = []
self.namefinder.names = []
self.namefinder.generic_visit(par.ast)
for symname in self.namefinder.names:
if (symname in self.current_params
and symname not in par.deps):
par.deps.append(symname)
self.asteval.symtable[name] = par.value
if par.name is None:
par.name = name
def __update_paramval(self, params, name):
# N.B. This does not use self.current_params but rather
# new Parameters that are being built by self.guess().
par = params[name]
if getattr(par, 'expr', None) is not None:
if getattr(par, 'ast', None) is None:
par.ast = self.asteval.parse(par.expr)
if par.deps is not None:
for dep in par.deps:
self.__update_paramval(params, dep)
par.value = self.asteval.run(par.ast)
out = check_ast_errors(self.asteval.error)
if out is not None:
self.asteval.raise_exception(None)
self.asteval.symtable[name] = par.value
def fit(self, *args, **kwargs):
"Use current_params unless overridden by arguments passed here."
guess = dict(self.current_params)
guess.update(self.kwargs) # from __init__, e.g. x=x
guess.update(kwargs)
self.current_result = self.model.fit(self._data, *args, **guess)
self.current_params = self.current_result.params
class BaseFitter(object):
__doc__ = _COMMON_DOC + """
Parameters
----------
data : array-like
model : lmfit.Model
optional initial Model to use, maybe be set or changed later
""" + _COMMON_EXAMPLES_DOC
def __init__(self, data, model=None, **kwargs):
self._data = data
self.kwargs = kwargs
# GUI-based subclasses need a default value for the menu of models,
# and so an arbitrary default is applied here, for uniformity
# among the subclasses.
if model is None:
model = ExponentialModel
self.model = model
def _on_model_value_change(self, name, value):
self.model = value
def _on_fit_button_click(self, b):
self.fit()
def _on_guess_button_click(self, b):
self.guess()
@property
def data(self):
return self._data
@data.setter
def data(self, value):
self._data = value
@property
def model(self):
return self._model
@model.setter
def model(self, value):
if callable(value):
model = value()
else:
model = value
self._model = model
self.current_result = None
self._current_params = model.make_params()
# Use these to evaluate any Parameters that use expressions.
self.asteval = Interpreter()
self.namefinder = NameFinder()
self._finalize_model(value)
self.guess()
def _finalize_model(self, value):
# subclasses optionally override to update display here
pass
@property
def current_params(self):
"""Each time fit() is called, these will be updated to reflect
the latest best params. They will be used as the initial guess
for the next fit, unless overridden by arguments to fit()."""
return self._current_params
@current_params.setter
def current_params(self, new_params):
# Copy contents, but retain original params objects.
for name, par in new_params.items():
self._current_params[name].value = par.value
self._current_params[name].expr = par.expr
self._current_params[name].vary = par.vary
self._current_params[name].min = par.min
self._current_params[name].max = par.max
# Compute values for expression-based Parameters.
self.__assign_deps(self._current_params)
for _, par in self._current_params.items():
if par.value is None:
self.__update_paramval(self._current_params, par.name)
self._finalize_params()
def _finalize_params(self):
# subclasses can override this to pass params to display
pass
def guess(self):
count_indep_vars = len(self.model.independent_vars)
guessing_successful = True
try:
if count_indep_vars == 0:
guess = self.model.guess(self._data)
elif count_indep_vars == 1:
key = self.model.independent_vars[0]
val = self.kwargs[key]
d = {key: val}
guess = self.model.guess(self._data, **d)
self.current_params = guess
except NotImplementedError:
guessing_successful = False
return guessing_successful
def __assign_deps(self, params):
# N.B. This does not use self.current_params but rather
# new Parameters that are being built by self.guess().
for name, par in params.items():
if par.expr is not None:
par.ast = self.asteval.parse(par.expr)
check_ast_errors(self.asteval.error)
par.deps = []
self.namefinder.names = []
self.namefinder.generic_visit(par.ast)
for symname in self.namefinder.names:
if (symname in self.current_params and symname not in
par.deps):
par.deps.append(symname)
self.asteval.symtable[name] = par.value
if par.name is None:
par.name = name
def __update_paramval(self, params, name):
# N.B. This does not use self.current_params but rather
# new Parameters that are being built by self.guess().
par = params[name]
if getattr(par, 'expr', None) is not None:
if getattr(par, 'ast', None) is None:
par.ast = self.asteval.parse(par.expr)
if par.deps is not None:
for dep in par.deps:
self.__update_paramval(params, dep)
par.value = self.asteval.run(par.ast)
out = check_ast_errors(self.asteval.error)
if out is not None:
self.asteval.raise_exception(None)
self.asteval.symtable[name] = par.value
def fit(self, *args, **kwargs):
"Use current_params unless overridden by arguments passed here."
guess = dict(self.current_params)
guess.update(self.kwargs) # from __init__, e.g. x=x
guess.update(kwargs)
self.current_result = self.model.fit(self._data, *args, **guess)
self.current_params = self.current_result.params
