Changeset 794 for mystic

Timestamp:

06/12/15 17:08:44 (11 months ago)

Author:

mmckerns

Message:

add _update_objective and _live, to queue state changes to cost, penalty, etc;
enable _clipGuess to randomize within RangeBoundary?, use numpy.clip;
move bulk of _bootstrap into SetObjective?, for better method-order freedom;
_decorate_objective less likely to produce a uniform population;
rename _Finalize to Finalize; Step responds to change in state more like Solve

Location:

mystic/mystic

Files:

• abstract_ensemble_solver.py (modified) (1 diff)
• abstract_solver.py (modified) (14 diffs)
• differential_evolution.py (modified) (7 diffs)
• scipy_optimize.py (modified) (4 diffs)

mystic/mystic/abstract_ensemble_solver.py

@@ -255 +255 @@
         return bool(msg)
 
+    def _update_objective(self):
+        """decorate the cost function with bounds, penalties, monitors, etc"""
+        # rewrap the cost if the solver has been run
+        self.Finalize()
+        return
+
 
 if __name__=='__main__':

mystic/mystic/abstract_solver.py

@@ -76 +76 @@
 
 
+import random
 import numpy
 from numpy import inf, shape, asarray, absolute, asfarray, seterr
@@ -155 +156 @@
         import mystic.termination
         self._EARLYEXIT       = mystic.termination.EARLYEXIT
+        self._live            = False 
         return
 
@@ -228 +230 @@
         else: #XXX: check if is arraylike?
             self._reducer = reducer
-        return
+        return self._update_objective()
 
     def SetPenalty(self, penalty):
@@ -247 +249 @@
         else: #XXX: check for format: y' = penalty(x) ?
             self._penalty = penalty
-        return
+        return self._update_objective()
 
     def SetConstraints(self, constraints):
@@ -263 +265 @@
         else: #XXX: check for format: x' = constraints(x) ?
             self._constraints = constraints
-        return
+        return self._update_objective()
 
     def SetGenerationMonitor(self, monitor, new=False):
@@ -312 +314 @@
         if min is False or max is False:
             self._useStrictRange = False
-            return
+            return self._update_objective()
         #XXX: better to use 'defaultMin,defaultMax' or '-inf,inf' ???
         if min is None: min = self._defaultMin
@@ -329 +331 @@
         self._strictMin = min
         self._strictMax = max
-        return
-
-    def _clipGuessWithinRangeBoundary(self, x0): #FIXME: use self.trialSolution?
+        return self._update_objective()
+
+    def _clipGuessWithinRangeBoundary(self, x0, at=True):
         """ensure that initial guess is set within bounds
 
@@ -339 +341 @@
        #    raise ValueError, "initial guess must be length %s" % self.nDim
         x0 = asarray(x0)
-        lo = self._strictMin
-        hi = self._strictMax
-        # crop x0 at bounds
+        bounds = (self._strictMin,self._strictMax)
+        if not len(self._strictMin): return x0
+        # clip x0 at bounds
         settings = numpy.seterr(all='ignore')
-        x0[x0<lo] = lo[x0<lo]
-        x0[x0>hi] = hi[x0>hi]
+        x_ = x0.clip(*bounds)
         numpy.seterr(**settings)
+        if at: return x_
+        # clip x0 within bounds
+        x_ = x_ != x0
+        x0[x_] = random.uniform(self._strictMin,self._strictMax)[x_]
         return x0
 
@@ -391 +396 @@
             if min[i] is None: min[i] = self._defaultMin[0]
             if max[i] is None: max[i] = self._defaultMax[0]
-        import random
         #generate random initial values
         for i in range(len(self.population)):
@@ -591 +595 @@
     def SetObjective(self, cost, ExtraArgs=None):  # callback=None/False ?
         """decorate the cost function with bounds, penalties, monitors, etc"""
-        self._bootstrap_objective(cost, ExtraArgs) # callback=null (see above)
-        return
-
-    def _decorate_objective(self, cost, ExtraArgs=None):
-        """decorate the cost function with bounds, penalties, monitors, etc"""
-        raw = cost
-        if ExtraArgs is None: ExtraArgs = ()
-        self._fcalls, cost = wrap_function(cost, ExtraArgs, self._evalmon)
-        if self._useStrictRange:
-            for i in range(self.nPop):
-                self.population[i] = self._clipGuessWithinRangeBoundary(self.population[i])
-            cost = wrap_bounds(cost, self._strictMin, self._strictMax)
-        cost = wrap_penalty(cost, self._penalty)
-        cost = wrap_nested(cost, self._constraints)
-        if self._reducer:
-           #cost = reduced(*self._reducer)(cost) # was self._reducer = (f,bool)
-            cost = reduced(self._reducer, arraylike=True)(cost)
-        # hold on to the 'wrapped' and 'raw' cost function
-        self._cost = (cost, raw, ExtraArgs)
-        return cost
-
-    def _bootstrap_objective(self, cost=None, ExtraArgs=None):
-        """HACK to enable not explicitly calling _decorate_objective"""
         _cost,_raw,_args = self._cost
         # check if need to 'wrap' or can return the stored cost
         if cost in [None, _raw, _cost] and ExtraArgs in [None, _args]:
-            return _cost
+            return
         # get cost and args if None was given
         if cost is None: cost = _raw
@@ -631 +612 @@
            #msg = '%s() invalid number of arguments (%d given)' % (name, val)
            #raise TypeError(msg)
+        # hold on to the 'raw' cost function
+        self._cost = (None, cost, ExtraArgs)
+        self._live = False
+        return
+
+    def _update_objective(self):
+        """decorate the cost function with bounds, penalties, monitors, etc"""
+        # rewrap the cost if the solver has been run
+        if False: # trigger immediately
+            self._decorate_objective(*self._cost[1:])
+        else: # delay update until _bootstrap
+            self.Finalize()
+        return
+
+    def _decorate_objective(self, cost, ExtraArgs=None):
+        """decorate the cost function with bounds, penalties, monitors, etc"""
+        #print ("@", cost, ExtraArgs, max)
+        raw = cost
+        if ExtraArgs is None: ExtraArgs = ()
+        self._fcalls, cost = wrap_function(cost, ExtraArgs, self._evalmon)
+        if self._useStrictRange:
+            indx = list(self.popEnergy).index(self.bestEnergy)
+            ngen = self.generations #XXX: no random if generations=0 ?
+            for i in range(self.nPop):
+                self.population[i] = self._clipGuessWithinRangeBoundary(self.population[i], (not ngen) or (i is indx))
+            cost = wrap_bounds(cost, self._strictMin, self._strictMax)
+        cost = wrap_penalty(cost, self._penalty)
+        cost = wrap_nested(cost, self._constraints)
+        if self._reducer:
+           #cost = reduced(*self._reducer)(cost) # was self._reducer = (f,bool)
+            cost = reduced(self._reducer, arraylike=True)(cost)
+        # hold on to the 'wrapped' and 'raw' cost function
+        self._cost = (cost, raw, ExtraArgs)
+        self._live = True
+        return cost
+
+    def _bootstrap_objective(self, cost=None, ExtraArgs=None):
+        """HACK to enable not explicitly calling _decorate_objective"""
+        _cost,_raw,_args = self._cost
+        # check if need to 'wrap' or can return the stored cost
+        if cost in [None, _raw, _cost] and ExtraArgs in [None, _args] \
+          and self._live:
+            return _cost
         # 'wrap' the 'new' cost function with _decorate
-        return self._decorate_objective(cost, args)
-        #XXX: **CAUTION** when _decorate called, solver._fcalls will be reset
+        self.SetObjective(cost, ExtraArgs)
+        return self._decorate_objective(*self._cost[1:])
+        #XXX: when _decorate called, solver._fcalls will be reset ?
 
     def _Step(self, cost=None, ExtraArgs=None, **kwds):
@@ -681 +706 @@
         return
 
-    def _Finalize(self, **kwds):
+    def Finalize(self, **kwds):
         """cleanup upon exiting the main optimization loop"""
-        pass
+        self._live = False
+        return
 
     def _process_inputs(self, kwds):
@@ -732 +758 @@
     If the algorithm does not meet the given termination conditions after
     the call to "Step", the solver may be left in an "out-of-sync" state.
-    When abandoning an non-terminated solver, one should call "_Finalize"
+    When abandoning an non-terminated solver, one should call "Finalize"
     to make sure the solver is fully returned to a "synchronized" state.
 
@@ -753 +779 @@
             self._Step(**kwds) #FIXME: not all kwds are given in __doc__
             if self.Terminated(): # then cleanup/finalize
-                self._Finalize()
+                self.Finalize()
 
             # get termination message and log state

mystic/mystic/differential_evolution.py

@@ -201 +201 @@
         return
 
+    def SetConstraints(self, constraints):
+        """apply a constraints function to the optimization
+
+input::
+    - a constraints function of the form: xk' = constraints(xk),
+      where xk is the current parameter vector. Ideally, this function
+      is constructed so the parameter vector it passes to the cost function
+      will satisfy the desired (i.e. encoded) constraints."""
+        if not constraints:
+            self._constraints = lambda x: x
+        elif not callable(constraints):
+            raise TypeError, "'%s' is not a callable function" % constraints
+        else: #XXX: check for format: x' = constraints(x) ?
+            self._constraints = constraints
+        return # doesn't use wrap_nested
+
     def _decorate_objective(self, cost, ExtraArgs=None):
         """decorate cost function with bounds, penalties, monitors, etc"""
+        #print ("@", cost, ExtraArgs, max)
         raw = cost
         if ExtraArgs is None: ExtraArgs = ()
         self._fcalls, cost = wrap_function(cost, ExtraArgs, self._evalmon)
         if self._useStrictRange:
+            indx = list(self.popEnergy).index(self.bestEnergy)
+            ngen = self.generations #XXX: no random if generations=0 ?
             for i in range(self.nPop):
-                self.population[i] = self._clipGuessWithinRangeBoundary(self.population[i])
+                self.population[i] = self._clipGuessWithinRangeBoundary(self.population[i], (not ngen) or (i is indx))
             cost = wrap_bounds(cost, self._strictMin, self._strictMax)
         cost = wrap_penalty(cost, self._penalty)
@@ -216 +235 @@
         # hold on to the 'wrapped' and 'raw' cost function
         self._cost = (cost, raw, ExtraArgs)
+        self._live = True
         return cost
 
@@ -221 +241 @@
         """perform a single optimization iteration
         Note that ExtraArgs should be a *tuple* of extra arguments"""
-        # HACK to enable not explicitly calling _decorate_objective
-        cost = self._bootstrap_objective(cost, ExtraArgs)
         # process and activate input settings
         settings = self._process_inputs(kwds)
         for key in settings:
             exec "%s = settings['%s']" % (key,key)
+
+        # HACK to enable not explicitly calling _decorate_objective
+        cost = self._bootstrap_objective(cost, ExtraArgs)
 
         init = False  # flag to do 0th iteration 'post-initialization'
@@ -372 +393 @@
         return
 
+    def SetConstraints(self, constraints):
+        """apply a constraints function to the optimization
+
+input::
+    - a constraints function of the form: xk' = constraints(xk),
+      where xk is the current parameter vector. Ideally, this function
+      is constructed so the parameter vector it passes to the cost function
+      will satisfy the desired (i.e. encoded) constraints."""
+        if not constraints:
+            self._constraints = lambda x: x
+        elif not callable(constraints):
+            raise TypeError, "'%s' is not a callable function" % constraints
+        else: #XXX: check for format: x' = constraints(x) ?
+            self._constraints = constraints
+        return # doesn't use wrap_nested
+
     def _decorate_objective(self, cost, ExtraArgs=None):
         """decorate cost function with bounds, penalties, monitors, etc"""
+        #print ("@", cost, ExtraArgs, max)
         raw = cost
         if ExtraArgs is None: ExtraArgs = ()
@@ -384 +422 @@
         fcalls, cost = wrap_function(cost, ExtraArgs, evalmon)
         if self._useStrictRange:
+            indx = list(self.popEnergy).index(self.bestEnergy)
+            ngen = self.generations #XXX: no random if generations=0 ?
             for i in range(self.nPop):
-                self.population[i] = self._clipGuessWithinRangeBoundary(self.population[i])
+                self.population[i] = self._clipGuessWithinRangeBoundary(self.population[i], (not ngen) or (i is indx))
             cost = wrap_bounds(cost, self._strictMin, self._strictMax)
         cost = wrap_penalty(cost, self._penalty)
@@ -393 +433 @@
         # hold on to the 'wrapped' and 'raw' cost function
         self._cost = (cost, raw, ExtraArgs)
+        self._live = True
         return cost
 
@@ -398 +439 @@
         """perform a single optimization iteration
         Note that ExtraArgs should be a *tuple* of extra arguments"""
-        # HACK to enable not explicitly calling _decorate_objective
-        cost = self._bootstrap_objective(cost, ExtraArgs)
         # process and activate input settings
         settings = self._process_inputs(kwds)
         for key in settings:
             exec "%s = settings['%s']" % (key,key)
+
+        # HACK to enable not explicitly calling _decorate_objective
+        cost = self._bootstrap_objective(cost, ExtraArgs)
 
         init = False  # flag to do 0th iteration 'post-initialization'

mystic/mystic/scipy_optimize.py

@@ -63 +63 @@
 
 
-from mystic.tools import unpair
+from mystic.tools import wrap_function, unpair, wrap_nested
+from mystic.tools import wrap_bounds, wrap_penalty, reduced
 
 import numpy
@@ -142 +143 @@
         return
 
+    def _decorate_objective(self, cost, ExtraArgs=None):
+        """decorate the cost function with bounds, penalties, monitors, etc"""
+        #print ("@", cost, ExtraArgs, max)
+        raw = cost
+        if ExtraArgs is None: ExtraArgs = ()
+        self._fcalls, cost = wrap_function(cost, ExtraArgs, self._evalmon)
+        if self._useStrictRange:
+            if self.generations:
+                #NOTE: pop[0] was best, may not be after resetting simplex
+                for i,j in enumerate(self._setSimplexWithinRangeBoundary()):
+                    self.population[i+1] = self.population[0].copy()
+                    self.population[i+1][i] = j
+            else:
+                self.population[0] = self._clipGuessWithinRangeBoundary(self.population[0])
+            cost = wrap_bounds(cost, self._strictMin, self._strictMax)
+        cost = wrap_penalty(cost, self._penalty)
+        cost = wrap_nested(cost, self._constraints)
+        if self._reducer:
+           #cost = reduced(*self._reducer)(cost) # was self._reducer = (f,bool)
+            cost = reduced(self._reducer, arraylike=True)(cost)
+        # hold on to the 'wrapped' and 'raw' cost function
+        self._cost = (cost, raw, ExtraArgs)
+        self._live = True
+        return cost
+
     def _Step(self, cost=None, ExtraArgs=None, **kwds):
         """perform a single optimization iteration
         Note that ExtraArgs should be a *tuple* of extra arguments"""
-        # HACK to enable not explicitly calling _decorate_objective
-        cost = self._bootstrap_objective(cost, ExtraArgs)
         # process and activate input settings
         settings = self._process_inputs(kwds)
         for key in settings:
             exec "%s = settings['%s']" % (key,key)
+
+        # HACK to enable not explicitly calling _decorate_objective
+        cost = self._bootstrap_objective(cost, ExtraArgs)
 
         rho = 1; chi = 2; psi = 0.5; sigma = 0.5;
@@ -466 +493 @@
         """perform a single optimization iteration
         Note that ExtraArgs should be a *tuple* of extra arguments"""
-        # HACK to enable not explicitly calling _decorate_objective
-        cost = self._bootstrap_objective(cost, ExtraArgs)
         # process and activate input settings
         settings = self._process_inputs(kwds)
         for key in settings:
             exec "%s = settings['%s']" % (key,key)
+
+        # HACK to enable not explicitly calling _decorate_objective
+        cost = self._bootstrap_objective(cost, ExtraArgs)
 
         direc = self._direc #XXX: throws Error if direc=None after generation=0
@@ -575 +603 @@
         return #XXX: call Terminated ?
 
-    def _Finalize(self, **kwds):
+    def Finalize(self, **kwds):
         """cleanup upon exiting the main optimization loop"""
-        self.energy_history = None # resync with 'best' energy
-        self._stepmon(self.bestSolution, self.bestEnergy, self.id)
-        # if savefrequency matches, then save state
-        self._AbstractSolver__save_state()
+        if self.energy_history != None:
+            self.energy_history = None # resync with 'best' energy
+            self._stepmon(self.bestSolution, self.bestEnergy, self.id)
+            # if savefrequency matches, then save state
+            self._AbstractSolver__save_state()
+        self._live = False
         return