Reverse Diff

AbstractFitEngine.py [6c00702:8d074d9] in sasview

File:

: 1 edited

src/sans/fit/AbstractFitEngine.py (modified) (15 diffs)

Legend:

: Unmodified
: Added
: Removed

src/sans/fit/AbstractFitEngine.py

-                      r6c00702
+                      r8d074d9
 #import logging
 import sys
+import math
 import numpy
+import math
+import park
 from sans.dataloader.data_info import Data1D
 from sans.dataloader.data_info import Data2D
+_SMALLVALUE = 1.0e-10
+class SansParameter(park.Parameter):
+    """
+    SANS model parameters for use in the PARK fitting service.
+    The parameter attribute value is redirected to the underlying
+    parameter value in the SANS model.
+    """
+    def __init__(self, name, model, data):
+        """
+            :param name: the name of the model parameter
+            :param model: the sans model to wrap as a park model
+        """
+        park.Parameter.__init__(self, name)
+        self._model, self._name = model, name
+        self.data = data
+        self.model = model
+        #set the value for the parameter of the given name
+        self.set(model.getParam(name))
+    def _getvalue(self):
+        """
+        override the _getvalue of park parameter
+        :return value the parameter associates with self.name
+        """
+        return self._model.getParam(self.name)
+    def _setvalue(self, value):
+        """
+        override the _setvalue pf park parameter
+        :param value: the value to set on a given parameter
+        """
+        self._model.setParam(self.name, value)
+    value = property(_getvalue, _setvalue)
+    def _getrange(self):
+        """
+        Override _getrange of park parameter
+        return the range of parameter
+        """
+        #if not  self.name in self._model.getDispParamList():
+        lo, hi = self._model.details[self.name][1:3]
+        if lo is None: lo = -numpy.inf
+        if hi is None: hi = numpy.inf
+        if lo > hi:
+            raise ValueError, "wrong fit range for parameters"
+        return lo, hi
+    def get_name(self):
+        """
+        """
+        return self._getname()
+    def _setrange(self, r):
+        """
+        override _setrange of park parameter
+        :param r: the value of the range to set
+        """
+        self._model.details[self.name][1:3] = r
+    range = property(_getrange, _setrange)
+class Model(park.Model):
+    """
+    PARK wrapper for SANS models.
+_SMALLVALUE = 1.0e-10
+# Note: duplicated from park
+class FitHandler(object):
+    """
+    Abstract interface for fit thread handler.
+    The methods in this class are called by the optimizer as the fit
+    progresses.
+    Note that it is up to the optimizer to call the fit handler correctly,
+    reporting all status changes and maintaining the 'done' flag.
+    """
+    done = False
+    """True when the fit job is complete"""
+    result = None
+    """The current best result of the fit"""
+    def improvement(self):
+        """
+        Called when a result is observed which is better than previous
+        results from the fit.
+        result is a FitResult object, with parameters, #calls and fitness.
+        """
+    def error(self, msg):
+        """
+        Model had an error; print traceback
+        """
+    def progress(self, current, expected):
+        """
+        Called each cycle of the fit, reporting the current and the
+        expected amount of work.   The meaning of these values is
+        optimizer dependent, but they can be converted into a percent
+        complete using (100*current)//expected.
+        Progress is updated each iteration of the fit, whatever that
+        means for the particular optimization algorithm.  It is called
+        after any calls to improvement for the iteration so that the
+        update handler can control I/O bandwidth by suppressing
+        intermediate improvements until the fit is complete.
+        """
+    def finalize(self):
+        """
+        Fit is complete; best results are reported
+        """
+    def abort(self):
+        """
+        Fit was aborted.
+        """
+    # TODO: not sure how these are used, but they are needed for running the fit
+    def update_fit(self, last=False): pass
+    def set_result(self, result=None): self.result = result
+class Model:
+    """
+    Fit wrapper for SANS models.
     """
     def __init__(self, sans_model, sans_data=None, **kw):
         """
         :param sans_model: the sans model to wrap using park interface
+        """
+        park.Model.__init__(self, **kw)
+        """
         self.model = sans_model
         self.name = sans_model.name
         self.data = sans_data
+        #list of parameters names
+        self.sansp = sans_model.getParamList()
+        #list of park parameter
+        self.parkp = [SansParameter(p, sans_model, sans_data) for p in self.sansp]
+        #list of parameter set
+        self.parameterset = park.ParameterSet(sans_model.name, pars=self.parkp)
+        self.pars = []
     def get_params(self, fitparams):
         """
         return a list of value of paramter to fit
         :param fitparams: list of paramaters name to fit
+        """
+        list_params = []
+        self.pars = []
+        self.pars = fitparams
+        for item in fitparams:
+            for element in self.parkp:
+                if element.name == str(item):
+                    list_params.append(element.value)
+        return list_params
+        """
+        return [self.model.getParam(k) for k in fitparams]
     def set_params(self, paramlist, params):
         """
         Set value for parameters to fit
         :param params: list of value for parameters to fit
+        """
+        try:
+            for i in range(len(self.parkp)):
+                for j in range(len(paramlist)):
+                    if self.parkp[i].name == paramlist[j]:
+                        self.parkp[i].value = params[j]
+                        self.model.setParam(self.parkp[i].name, params[j])
+        except:
+            raise
+        """
+        for k,v in zip(paramlist, params):
+            self.model.setParam(k,v)
+    def set(self, **kw):
+        self.set_params(*zip(*kw.items()))
     def eval(self, x):
         """
             Override eval method of park model.
             :param x: the x value used to compute a function
         """
 …
         except:
             raise
     def eval_derivs(self, x, pars=[]):
         """
 …
         instead of calling eval.
         """
+        return []
+        raise NotImplementedError('no derivatives available')
+    def __call__(self, x):
+        return self.eval(x)
 class FitData1D(Data1D):
     """
 …
         """
         Data1D.__init__(self, x=x, y=y, dx=dx, dy=dy)
+        self.num_points = len(x)
         self.sans_data = data
         self.smearer = smearer
 …
         """
         return self.qmin, self.qmax
+    def size(self):
+        """
+        Number of measurement points in data set after masking, etc.
+        """
+        return len(self.x)
     def residuals(self, fn):
         """
 …
     def __init__(self, sans_data2d, data=None, err_data=None):
         Data2D.__init__(self, data=data, err_data=err_data)
+        """
+            Data can be initital with a data (sans plottable)
+            or with vectors.
+        """
+        # Data can be initialized with a sans plottable or with vectors.
         self.res_err_image = []
+        self.num_points = 0 # will be set by set_data
         self.idx = []
         self.qmin = None
 …
         self.idx = (self.idx) & (self.mask)
         self.idx = (self.idx) & (numpy.isfinite(self.data))
+        self.num_points = numpy.sum(self.idx)
     def set_smearer(self, smearer):
 …
         """
         return self.qmin, self.qmax
+    def size(self):
+        """
+        Number of measurement points in data set after masking, etc.
+        """
+        return numpy.sum(self.idx)
     def residuals(self, fn):
         """
 …
+class SansAssembly:
+    """
+    Sans Assembly class a class wrapper to be call in optimizer.leastsq method
+    """
+    def __init__(self, paramlist, model=None, data=None, fitresult=None,
+                 handler=None, curr_thread=None, msg_q=None):
+        """
+        :param Model: the model wrapper fro sans -model
+        :param Data: the data wrapper for sans data
+        """
+        self.model = model
+        self.data = data
+        self.paramlist = paramlist
+        self.msg_q = msg_q
+        self.curr_thread = curr_thread
+        self.handler = handler
+        self.fitresult = fitresult
+        self.res = []
+        self.true_res = []
+        self.func_name = "Functor"
+        self.theory = None
+    def chisq(self):
+        """
+        Calculates chi^2
+        :param params: list of parameter values
+        :return: chi^2
+        """
+        total = 0
+        for item in self.true_res:
+            total += item * item
+        if len(self.true_res) == 0:
+            return None
+        return total / len(self.true_res)
+    def __call__(self, params):
+        """
+            Compute residuals
+            :param params: value of parameters to fit
+        """
+        #import thread
+        self.model.set_params(self.paramlist, params)
+        #print "params", params
+        self.true_res, theory = self.data.residuals(self.model.eval)
+        self.theory = copy.deepcopy(theory)
+        # check parameters range
+        if self.check_param_range():
+            # if the param value is outside of the bound
+            # just silent return res = inf
+            return self.res
+        self.res = self.true_res
+        if self.fitresult is not None:
+            self.fitresult.set_model(model=self.model)
+            self.fitresult.residuals = self.true_res
+            self.fitresult.iterations += 1
+            self.fitresult.theory = theory
+            #fitness = self.chisq(params=params)
+            fitness = self.chisq()
+            self.fitresult.pvec = params
+            self.fitresult.set_fitness(fitness=fitness)
+            if self.msg_q is not None:
+                self.msg_q.put(self.fitresult)
+            if self.handler is not None:
+                self.handler.set_result(result=self.fitresult)
+                self.handler.update_fit()
+            if self.curr_thread != None:
+                try:
+                    self.curr_thread.isquit()
+                except:
+                    #msg = "Fitting: Terminated...       Note: Forcing to stop "
+                    #msg += "fitting may cause a 'Functor error message' "
+                    #msg += "being recorded in the log file....."
+                    #self.handler.stop(msg)
+                    raise
+        return self.res
+    def check_param_range(self):
+        """
+        Check the lower and upper bound of the parameter value
+        and set res to the inf if the value is outside of the
+        range
+        :limitation: the initial values must be within range.
+        """
+        #time.sleep(0.01)
+        is_outofbound = False
+        # loop through the fit parameters
+        for p in self.model.parameterset:
+            param_name = p.get_name()
+            if param_name in self.paramlist:
+                # if the range was defined, check the range
+                if numpy.isfinite(p.range[0]):
+                    if p.value == 0:
+                        # This value works on Scipy
+                        # Do not change numbers below
+                        value = _SMALLVALUE
+                    else:
+                        value = p.value
+                    # For leastsq, it needs a bit step back from the boundary
+                    val = p.range[0] - value * _SMALLVALUE
+                    if p.value < val:
+                        self.res *= 1e+6
+                        is_outofbound = True
+                        break
+                if numpy.isfinite(p.range[1]):
+                    # This value works on Scipy
+                    # Do not change numbers below
+                    if p.value == 0:
+                        value = _SMALLVALUE
+                    else:
+                        value = p.value
+                    # For leastsq, it needs a bit step back from the boundary
+                    val = p.range[1] + value * _SMALLVALUE
+                    if p.value > val:
+                        self.res *= 1e+6
+                        is_outofbound = True
+                        break
+        return is_outofbound
 class FitEngine:
     def __init__(self):
 …
         """
+        if model == None:
+            raise ValueError, "AbstractFitEngine: Need to set model to fit"
+        new_model = model
+        if not pars:
+            raise ValueError("no fitting parameters")
+        if model is None:
+            raise ValueError("no model to fit")
         if not issubclass(model.__class__, Model):
+            new_model = Model(model, data)
+        if len(constraints) > 0:
+            for constraint in constraints:
+                name, value = constraint
+                try:
+                    new_model.parameterset[str(name)].set(str(value))
+                except:
+                    msg = "Fit Engine: Error occurs when setting the constraint"
+                    msg += " %s for parameter %s " % (value, name)
+                    raise ValueError, msg
+        if len(pars) > 0:
+            temp = []
+            for item in pars:
+                if item in new_model.model.getParamList():
+                    temp.append(item)
+                    self.param_list.append(item)
+                else:
+                    msg = "wrong parameter %s used " % str(item)
+                    msg += "to set model %s. Choose " % str(new_model.model.name)
+                    msg += "parameter name within %s" % \
+                                str(new_model.model.getParamList())
+                    raise ValueError, msg
+            #A fitArrange is already created but contains data_list only at id
+            if self.fit_arrange_dict.has_key(id):
+                self.fit_arrange_dict[id].set_model(new_model)
+                self.fit_arrange_dict[id].pars = pars
+            else:
+            #no fitArrange object has been create with this id
+                fitproblem = FitArrange()
+                fitproblem.set_model(new_model)
+                fitproblem.pars = pars
+                self.fit_arrange_dict[id] = fitproblem
+                vals = []
+                for name in pars:
+                    vals.append(new_model.model.getParam(name))
+                self.fit_arrange_dict[id].vals = vals
+        else:
+            raise ValueError, "park_integration:missing parameters"
+            model = Model(model, data)
+        sasmodel = model.model
+        available_parameters = sasmodel.getParamList()
+        for p in pars:
+            if p not in available_parameters:
+                raise ValueError("parameter %s not available in model %s; use one of [%s] instead"
+                                 %(p, sasmodel.name, ", ".join(available_parameters)))
+        if id not in self.fit_arrange_dict:
+            self.fit_arrange_dict[id] = FitArrange()
+        self.fit_arrange_dict[id].set_model(model)
+        self.fit_arrange_dict[id].pars = pars
+        self.fit_arrange_dict[id].vals = [sasmodel.getParam(name) for name in pars]
+        self.fit_arrange_dict[id].constraints = constraints
+        self.param_list.extend(pars)
     def set_data(self, data, id, smearer=None, qmin=None, qmax=None):
         """
 …
         self.vals = []
         self.selected = 0
     def set_model(self, model):
         """
 …
         """
         return self.selected
-IS_MAC = True
-if sys.platform.count("win32") > 0:
-    IS_MAC = False
 class FResult(object):
 …
     def __init__(self, model=None, param_list=None, data=None):
         self.calls = None
-        self.pars = []
         self.fitness = None
         self.chisqr = None
 …
         self.residuals = []
         self.index = []
-        self.parameters = None
-        self.is_mac = IS_MAC
         self.model = model
         self.data = data
 …
         if self.pvec == None and self.model is None and self.param_list is None:
             return "No results"
+        n = len(self.model.parameterset)
+        result_param = zip(xrange(n), self.model.parameterset)
+        msg1 = ["[Iteration #: %s ]" % self.iterations]
+        msg3 = ["=== goodness of fit: %s ===" % (str(self.fitness))]
+        if not self.is_mac:
+            msg2 = ["P%-3d  %s......|.....%s" % \
+                (p[0], p[1], p[1].value)\
+                  for p in result_param if p[1].name in self.param_list]
+            msg = msg1 + msg3 + msg2
+        else:
+            msg = msg1 + msg3
+        msg = "\n".join(msg)
+        return msg
+        sasmodel = self.model.model
+        pars = enumerate(sasmodel.getParamList())
+        msg1 = "[Iteration #: %s ]" % self.iterations
+        msg3 = "=== goodness of fit: %s ===" % (str(self.fitness))
+        msg2 = ["P%-3d  %s......|.....%s" % (i, v, sasmodel.getParam(v))
+                for i,v in pars if v in self.param_list]
+        msg = [msg1, msg3] + msg2
+        return "\n".join(msg)
     def print_summary(self):
         """
         """
         print self
+        print str(self)

Note: See TracChangeset for help on using the changeset viewer.

SasView

Changes in src/sans/fit/AbstractFitEngine.py [6c00702:8d074d9] in sasview

Legend:

src/sans/fit/AbstractFitEngine.py

Download in other formats: