Changeset 748

Timestamp:

08/12/14 11:13:17 (22 months ago)

Author:

mmckerns

Message:

add solver one-liners for ensemble solvers; fix: reducer in ensemble solvers

Location:

mystic/mystic

Files:

• abstract_ensemble_solver.py (modified) (2 diffs)
• differential_evolution.py (modified) (6 diffs)
• ensemble.py (modified) (1 diff)
• scipy_optimize.py (modified) (2 diffs)
• solvers.py (modified) (2 diffs)

mystic/mystic/abstract_ensemble_solver.py

@@ -166 +166 @@
         solver.SetConstraints(self._constraints)
         solver.SetPenalty(self._penalty)
-        if self._reducer[0]: #XXX: always, settable, or sync'd ?
-            solver.SetReducer(*self._reducer)
+        if self._reducer: #XXX: always, settable, or sync'd ?
+            solver.SetReducer(self._reducer, arraylike=True)
         return solver
 
@@ -243 +243 @@
             print "         Iterations: %d" % solver.generations
             print "         Function evaluations: %d" % solver._fcalls[0]
-            print "         Total Function evaluations: %d" % self._total_evals
+            print "         Total function evaluations: %d" % self._total_evals
 
         if info:

mystic/mystic/differential_evolution.py

@@ -284 +284 @@
 Description:
 
-    Uses a differential evolution algorith to find the minimum of
+    Uses a differential evolution algorithm to find the minimum of
     a function of one or more variables.
 
@@ -439 +439 @@
 Description:
 
-    Uses a differential evolution algorith to find the minimum of
+    Uses a differential evolution algorithm to find the minimum of
     a function of one or more variables. This implementation holds
     the current generation invariant until the end of each iteration.
@@ -478 +478 @@
 Description:
 
-    Uses Storn & Prices's differential evolution algorith to find the minimum
+    Uses Storn & Prices's differential evolution algorithm to find the minimum
     of a function of one or more variables. Mimics a scipy.optimize style
     interface.
@@ -506 +506 @@
         iteration.  It is called as callback(xk), where xk is the
         current parameter vector.
-    handler -- boolean - enable/disable handling of interrupt signal
-    strategy -- strategy - override the default mutation strategy
-    itermon -- monitor - override the default GenerationMonitor
-    evalmon -- monitor - override the default EvaluationMonitor
+    handler -- boolean - enable/disable handling of interrupt signal.
+    strategy -- strategy - override the default mutation strategy.
+    itermon -- monitor - override the default GenerationMonitor.
+    evalmon -- monitor - override the default EvaluationMonitor.
     constraints -- an optional user-supplied function.  It is called as
         constraints(xk), where xk is the current parameter vector.
@@ -548 +548 @@
 Description:
 
-    Uses a differential evolution algorith to find the minimum of
+    Uses a differential evolution algorithm to find the minimum of
     a function of one or more variables. Mimics a scipy.optimize style
     interface.
@@ -576 +576 @@
         iteration.  It is called as callback(xk), where xk is the
         current parameter vector.
-    handler -- boolean - enable/disable handling of interrupt signal
-    strategy -- strategy - override the default mutation strategy
-    itermon -- monitor - override the default GenerationMonitor
-    evalmon -- monitor - override the default EvaluationMonitor
+    handler -- boolean - enable/disable handling of interrupt signal.
+    strategy -- strategy - override the default mutation strategy.
+    itermon -- monitor - override the default GenerationMonitor.
+    evalmon -- monitor - override the default EvaluationMonitor.
     constraints -- an optional user-supplied function.  It is called as
         constraints(xk), where xk is the current parameter vector.

mystic/mystic/ensemble.py

@@ -361 +361 @@
         return 
 
+
+def lattice(cost,ndim,nbins=2,args=(),bounds=None,ftol=1e-4,maxiter=None, \
+            maxfun=None,full_output=0,disp=1,retall=0,callback=None,**kwds):
+    """Minimize a function using the lattice ensemble solver.
+    
+Description:
+
+    Uses a lattice ensemble algorithm to find the minimum of
+    a function of one or more variables. Mimics the scipy.optimize.fmin
+    interface. Starts N solver instances at regular intervals in parameter
+    space, determined by 'nbins' (N = numpy.prod(nbins); len(nbins) == ndim). 
+
+Inputs:
+
+    cost -- the Python function or method to be minimized.
+    ndim -- dimensionality of the problem.
+    nbins -- tuple of number of bins in each dimension.
+
+Additional Inputs:
+
+    args -- extra arguments for cost.
+    bounds -- list - n pairs of bounds (min,max), one pair for each parameter.
+    ftol -- number - acceptable relative error in cost(xopt) for convergence.
+    gtol -- number - maximum number of iterations to run without improvement.
+    maxiter -- number - the maximum number of iterations to perform.
+    maxfun -- number - the maximum number of function evaluations.
+    full_output -- number - non-zero if fval and warnflag outputs are desired.
+    disp -- number - non-zero to print convergence messages.
+    retall -- number - non-zero to return list of solutions at each iteration.
+    callback -- an optional user-supplied function to call after each
+        iteration.  It is called as callback(xk), where xk is the
+        current parameter vector.
+    solver -- solver - override the default nested Solver instance.
+    handler -- boolean - enable/disable handling of interrupt signal.
+    itermon -- monitor - override the default GenerationMonitor.
+    evalmon -- monitor - override the default EvaluationMonitor.
+    constraints -- an optional user-supplied function.  It is called as
+        constraints(xk), where xk is the current parameter vector.
+        This function must return xk', a parameter vector that satisfies
+        the encoded constraints.
+    penalty -- an optional user-supplied function.  It is called as
+        penalty(xk), where xk is the current parameter vector.
+        This function should return y', with y' == 0 when the encoded
+        constraints are satisfied, and y' > 0 otherwise.
+
+Returns: (xopt, {fopt, iter, funcalls, warnflag, allfuncalls}, {allvecs})
+
+    xopt -- ndarray - minimizer of function
+    fopt -- number - value of function at minimum: fopt = cost(xopt)
+    iter -- number - number of iterations
+    funcalls -- number - number of function calls
+    warnflag -- number - Integer warning flag:
+        1 : 'Maximum number of function evaluations.'
+        2 : 'Maximum number of iterations.'
+    allfuncalls -- number - total function calls (for all solver instances)
+    allvecs -- list - a list of solutions at each iteration
+
+    """
+    handler = False
+    if kwds.has_key('handler'):
+        handler = kwds['handler']
+    from mystic.solvers import NelderMeadSimplexSolver as _solver
+    if kwds.has_key('solver'):
+        _solver = kwds['solver']
+
+    from mystic.monitors import Monitor
+    stepmon = Monitor()
+    evalmon = Monitor()
+    if kwds.has_key('itermon'):
+        stepmon = kwds['itermon']
+    if kwds.has_key('evalmon'):
+        evalmon = kwds['evalmon']
+
+    gtol = 10 # termination generations (scipy: 2, default: 10)
+    if kwds.has_key('gtol'):
+        gtol = kwds['gtol']
+    if gtol: #if number of generations is provided, use NCOG
+        from mystic.termination import NormalizedChangeOverGeneration
+        termination = NormalizedChangeOverGeneration(ftol,gtol)
+    else:
+        from mystic.termination import VTRChangeOverGeneration
+        termination = VTRChangeOverGeneration(ftol)
+
+    if isinstance(nbins, int): nbins = [nbins]*ndim
+
+    solver = LatticeSolver(ndim,nbins)
+    solver.SetNestedSolver(_solver) #XXX: skip settings for configured solver?
+    solver.SetEvaluationLimits(maxiter,maxfun)
+    solver.SetEvaluationMonitor(evalmon)
+    solver.SetGenerationMonitor(stepmon)
+    if kwds.has_key('penalty'):
+        penalty = kwds['penalty']
+        solver.SetPenalty(penalty)
+    if kwds.has_key('constraints'):
+        constraints = kwds['constraints']
+        solver.SetConstraints(constraints)
+    if bounds is not None:
+        minb,maxb = unpair(bounds)
+        solver.SetStrictRanges(minb,maxb)
+
+    if handler: solver.enable_signal_handler()
+    solver.Solve(cost,termination=termination,disp=disp, \
+                 ExtraArgs=args,callback=callback)
+    solution = solver.Solution()
+
+    # code below here pushes output to scipy.optimize.fmin interface
+    msg = solver.CheckTermination(disp=disp, info=True)
+
+    x = solver.bestSolution
+    fval = solver.bestEnergy
+    warnflag = 0
+    fcalls = solver.evaluations
+    all_fcalls = solver._total_evals
+    iterations = max(0,len(solver._stepmon.y)-1) #FIXME: solver.generations
+    allvecs = solver._stepmon.x
+
+    if fcalls >= solver._maxfun: #XXX: check against total or individual?
+        warnflag = 1
+    elif iterations >= solver._maxiter: #XXX: check against total or individual?
+        warnflag = 2
+    else: pass
+
+    if full_output:
+        retlist = x, fval, iterations, fcalls, warnflag, all_fcalls
+        if retall:
+            retlist += (allvecs,)
+    else:
+        retlist = x
+        if retall:
+            retlist = (x, allvecs)
+
+    return retlist
+
+
+def buckshot(cost,ndim,npts=8,args=(),bounds=None,ftol=1e-4,maxiter=None, \
+             maxfun=None,full_output=0,disp=1,retall=0,callback=None,**kwds):
+    """Minimize a function using the buckshot ensemble solver.
+    
+Description:
+
+    Uses a buckshot ensemble algorithm to find the minimum of
+    a function of one or more variables. Mimics the scipy.optimize.fmin
+    interface. Starts 'npts' solver instances at random points in parameter
+    space. 
+
+Inputs:
+
+    cost -- the Python function or method to be minimized.
+    ndim -- dimensionality of the problem.
+    npts -- number of solver instances.
+
+Additional Inputs:
+
+    args -- extra arguments for cost.
+    bounds -- list - n pairs of bounds (min,max), one pair for each parameter.
+    ftol -- number - acceptable relative error in cost(xopt) for convergence.
+    gtol -- number - maximum number of iterations to run without improvement.
+    maxiter -- number - the maximum number of iterations to perform.
+    maxfun -- number - the maximum number of function evaluations.
+    full_output -- number - non-zero if fval and warnflag outputs are desired.
+    disp -- number - non-zero to print convergence messages.
+    retall -- number - non-zero to return list of solutions at each iteration.
+    callback -- an optional user-supplied function to call after each
+        iteration.  It is called as callback(xk), where xk is the
+        current parameter vector.
+    solver -- solver - override the default nested Solver instance.
+    handler -- boolean - enable/disable handling of interrupt signal.
+    itermon -- monitor - override the default GenerationMonitor.
+    evalmon -- monitor - override the default EvaluationMonitor.
+    constraints -- an optional user-supplied function.  It is called as
+        constraints(xk), where xk is the current parameter vector.
+        This function must return xk', a parameter vector that satisfies
+        the encoded constraints.
+    penalty -- an optional user-supplied function.  It is called as
+        penalty(xk), where xk is the current parameter vector.
+        This function should return y', with y' == 0 when the encoded
+        constraints are satisfied, and y' > 0 otherwise.
+
+Returns: (xopt, {fopt, iter, funcalls, warnflag, allfuncalls}, {allvecs})
+
+    xopt -- ndarray - minimizer of function
+    fopt -- number - value of function at minimum: fopt = cost(xopt)
+    iter -- number - number of iterations
+    funcalls -- number - number of function calls
+    warnflag -- number - Integer warning flag:
+        1 : 'Maximum number of function evaluations.'
+        2 : 'Maximum number of iterations.'
+    allfuncalls -- number - total function calls (for all solver instances)
+    allvecs -- list - a list of solutions at each iteration
+
+    """
+    handler = False
+    if kwds.has_key('handler'):
+        handler = kwds['handler']
+    from mystic.solvers import NelderMeadSimplexSolver as _solver
+    if kwds.has_key('solver'):
+        _solver = kwds['solver']
+
+    from mystic.monitors import Monitor
+    stepmon = Monitor()
+    evalmon = Monitor()
+    if kwds.has_key('itermon'):
+        stepmon = kwds['itermon']
+    if kwds.has_key('evalmon'):
+        evalmon = kwds['evalmon']
+
+    gtol = 10 # termination generations (scipy: 2, default: 10)
+    if kwds.has_key('gtol'):
+        gtol = kwds['gtol']
+    if gtol: #if number of generations is provided, use NCOG
+        from mystic.termination import NormalizedChangeOverGeneration
+        termination = NormalizedChangeOverGeneration(ftol,gtol)
+    else:
+        from mystic.termination import VTRChangeOverGeneration
+        termination = VTRChangeOverGeneration(ftol)
+
+    solver = BuckshotSolver(ndim,npts)
+    solver.SetNestedSolver(_solver) #XXX: skip settings for configured solver?
+    solver.SetEvaluationLimits(maxiter,maxfun)
+    solver.SetEvaluationMonitor(evalmon)
+    solver.SetGenerationMonitor(stepmon)
+    if kwds.has_key('penalty'):
+        penalty = kwds['penalty']
+        solver.SetPenalty(penalty)
+    if kwds.has_key('constraints'):
+        constraints = kwds['constraints']
+        solver.SetConstraints(constraints)
+    if bounds is not None:
+        minb,maxb = unpair(bounds)
+        solver.SetStrictRanges(minb,maxb)
+
+    if handler: solver.enable_signal_handler()
+    solver.Solve(cost,termination=termination,disp=disp, \
+                 ExtraArgs=args,callback=callback)
+    solution = solver.Solution()
+
+    # code below here pushes output to scipy.optimize.fmin interface
+    msg = solver.CheckTermination(disp=disp, info=True)
+
+    x = solver.bestSolution
+    fval = solver.bestEnergy
+    warnflag = 0
+    fcalls = solver.evaluations
+    all_fcalls = solver._total_evals
+    iterations = max(0,len(solver._stepmon.y)-1) #FIXME: solver.generations
+    allvecs = solver._stepmon.x
+
+    if fcalls >= solver._maxfun: #XXX: check against total or individual?
+        warnflag = 1
+    elif iterations >= solver._maxiter: #XXX: check against total or individual?
+        warnflag = 2
+    else: pass
+
+    if full_output:
+        retlist = x, fval, iterations, fcalls, warnflag, all_fcalls
+        if retall:
+            retlist += (allvecs,)
+    else:
+        retlist = x
+        if retall:
+            retlist = (x, allvecs)
+
+    return retlist
+
+
+
 # backward compatibility
 ScattershotSolver = BuckshotSolver

mystic/mystic/scipy_optimize.py

@@ -326 +326 @@
         iteration.  It is called as callback(xk), where xk is the
         current parameter vector.
-    handler -- boolean - enable/disable handling of interrupt signal
-    itermon -- monitor - override the default GenerationMonitor
-    evalmon -- monitor - override the default EvaluationMonitor
+    handler -- boolean - enable/disable handling of interrupt signal.
+    itermon -- monitor - override the default GenerationMonitor.
+    evalmon -- monitor - override the default EvaluationMonitor.
     constraints -- an optional user-supplied function.  It is called as
         constraints(xk), where xk is the current parameter vector.
@@ -645 +645 @@
         iteration.  It is called as callback(xk), where xk is the
         current parameter vector.
-    direc -- initial direction set
-    handler -- boolean - enable/disable handling of interrupt signal
-    itermon -- monitor - override the default GenerationMonitor
-    evalmon -- monitor - override the default EvaluationMonitor
+    direc -- initial direction set.
+    handler -- boolean - enable/disable handling of interrupt signal.
+    itermon -- monitor - override the default GenerationMonitor.
+    evalmon -- monitor - override the default EvaluationMonitor.
     constraints -- an optional user-supplied function.  It is called as
         constraints(xk), where xk is the current parameter vector.

mystic/mystic/solvers.py

@@ -38 +38 @@
     diffev      -- DifferentialEvolutionSolver
     diffev2     -- DifferentialEvolutionSolver2
+    == Pseudo-Global Optimizers ==
+    buckshot    -- BuckshotSolver
+    lattice     -- LatticeSolver
     == Local-Search Optimizers ==
     fmin        -- NelderMeadSimplexSolver
@@ -66 +69 @@
 from ensemble import BuckshotSolver
 from ensemble import LatticeSolver
+from ensemble import buckshot, lattice
 
 # local-search optimizers