fcmaes 1.1.3__py3-none-any.whl → 1.6.9__py3-none-any.whl

fcmaes/cmaes.py

@@ -12,36 +12,43 @@ import sys
 import os
 import math
 import numpy as np
+from time import time
+import ctypes as ct
+import multiprocessing as mp
 from scipy import linalg
-from scipy.optimize import OptimizeResult
-from numpy.random import MT19937, Generator
-from fcmaes.evaluator import Evaluator, eval_parallel
+from scipy.optimize import OptimizeResult, Bounds
+from numpy.random import PCG64DXSM, Generator
+from fcmaes.evaluator import Evaluator, serial, _check_bounds, _fitness, is_debug_active
+
+from loguru import logger
+from typing import Optional, Callable, Union
+from numpy.typing import ArrayLike
 
 os.environ['MKL_DEBUG_CPU_TYPE'] = '5'
 
-def minimize(fun, 
-             bounds=None, 
-             x0=None, 
-             input_sigma = 0.3, 
-             popsize = 31, 
-             max_evaluations = 100000, 
-             max_iterations = 100000,  
-             workers = None,
-             accuracy = 1.0, 
-             stop_fittness = np.nan, 
-             is_terminate = None, 
-             rg = Generator(MT19937()),
-             runid=0):    
+def minimize(fun: Callable[[ArrayLike], float], 
+             bounds: Optional[Bounds] = None, 
+             x0: Optional[ArrayLike] = None,
+             input_sigma: Optional[Union[float, ArrayLike, Callable]] = 0.3,
+             popsize: Optional[int] = 31,
+             max_evaluations: Optional[int]  = 100000,
+             max_iterations: Optional[int]  = 100000,
+             workers: Optional[int]  = 1,
+             accuracy: Optional[float] = 1.0,
+             stop_fitness: Optional[float] = -np.inf,
+             is_terminate: Optional[Callable[[ArrayLike, float], bool]]  = None,
+             rg: Optional[Generator] = Generator(PCG64DXSM()),
+             runid: Optional[int] = 0,
+             normalize: Optional[bool] = True,
+             update_gap: Optional[int] = None) -> OptimizeResult:
     """Minimization of a scalar function of one or more variables using CMA-ES.
      
     Parameters
     ----------
     fun : callable
         The objective function to be minimized.
-            ``fun(x, *args) -> float``
-        where ``x`` is an 1-D array with shape (n,) and ``args``
-        is a tuple of the fixed parameters needed to completely
-        specify the function.
+            ``fun(x) -> float``
+        where ``x`` is an 1-D array with shape (n,)
     bounds : sequence or `Bounds`, optional
         Bounds on variables. There are two ways to specify the bounds:
             1. Instance of the `scipy.Bounds` class.
@@ -59,11 +66,11 @@ def minimize(fun,
     max_iterations : int, optional
         Forced termination after ``max_iterations`` iterations.
     workers : int or None, optional
-        If not workers is None, function evaluation is performed in parallel for the whole population. 
+        If workers > 1, function evaluation is performed in parallel for the whole population. 
         Useful for costly objective functions but is deactivated for parallel retry.      
     accuracy : float, optional
         values > 1.0 reduce the accuracy.
-    stop_fittness : float, optional 
+    stop_fitness : float, optional 
          Limit for fitness value. If reached minimize terminates.
     is_terminate : callable, optional
         Callback to be used if the caller of minimize wants to 
@@ -72,7 +79,11 @@ def minimize(fun,
         Random generator for creating random guesses.
     runid : int, optional
         id used by the is_terminate callback to identify the CMA-ES run. 
-    
+    normalize : boolean, optional
+        pheno -> if true geno transformation maps arguments to interval [-1,1] 
+    update_gap : int, optional
+        number of iterations without distribution update
+   
     Returns
     -------
     res : scipy.OptimizeResult
@@ -81,42 +92,47 @@ def minimize(fun,
         ``fun`` the best function value, ``nfev`` the number of function evaluations,
         ``nit`` the number of CMA-ES iterations, ``status`` the stopping critera and
         ``success`` a Boolean flag indicating if the optimizer exited successfully. """
-   
-    fun = serial(fun) if workers is None else parallel(fun, workers)
+  
+    if workers is None or workers <= 1:
+        fun = serial(fun)        
     cmaes = Cmaes(bounds, x0, 
-                  input_sigma, popsize, 
-                  max_evaluations, max_iterations, 
-                  accuracy, stop_fittness, 
-                  is_terminate, rg, np.random.randn, runid, fun)
-    x, val, evals, iterations, stop = cmaes.doOptimize()
-    if not workers is None:
-        fun.stop() # stop all parallel evaluation processes
+                      input_sigma, popsize, 
+                      max_evaluations, max_iterations, 
+                      accuracy, stop_fitness, 
+                      is_terminate, rg, np.random.randn, runid, normalize, 
+                      update_gap, fun)        
+    if workers and workers > 1:
+        x, val, evals, iterations, stop = cmaes.do_optimize_delayed_update(fun, workers=workers)
+    else:      
+        x, val, evals, iterations, stop = cmaes.doOptimize()
     return OptimizeResult(x=x, fun=val, nfev=evals, nit=iterations, status=stop, 
                           success=True)
 
 class Cmaes(object):
     """Implements the cma-es ask/tell interactive interface."""
     
-    def __init__(self, bounds=None, 
-                        x0=None, 
-                        input_sigma = 0.3, 
-                        popsize = 31, 
-                        max_evaluations = 100000, 
-                        max_iterations = 100000,  
-                        accuracy = 1.0, 
-                        stop_fittness = np.nan, 
-                        is_terminate = None, 
-                        rg = Generator(MT19937()), # used if x0 is undefined
-                        randn = np.random.randn, # used for random offspring 
-                        runid=0, 
-                        fun = None
+    def __init__(self, bounds: Optional[Bounds] = None,
+                        x0: Optional[ArrayLike] = None,
+                        input_sigma: Optional[Union[float, ArrayLike, Callable]] = 0.3,
+                        popsize: Optional[int] = 31,
+                        max_evaluations: Optional[int] = 100000,
+                        max_iterations: Optional[int] = 100000,
+                        accuracy: Optional[int] = 1.0,
+                        stop_fitness: Optional[float] = -np.inf,
+                        is_terminate: Optional[bool] = None,
+                        rg: Optional[Generator] = Generator(PCG64DXSM()), # used if x0 is undefined
+                        randn: Optional[Callable] = np.random.randn, # used for random offspring 
+                        runid: Optional[int] = 0,
+                        normalize: Optional[bool] = True,
+                        update_gap: Optional[int] = None,
+                        fun: Optional[Callable[[ArrayLike], float]] = None
                         ):
                         
     # runid used in is_terminate callback to identify a specific run at different iteration
         self.runid = runid
     # bounds and guess
         lower, upper, guess = _check_bounds(bounds, x0, rg)   
-        self.fitfun = _Fittness(fun, lower, upper)
+        self.fitfun = _fitness(fun, lower, upper, normalize)
     # initial guess for the arguments of the fitness function
         self.guess = self.fitfun.encode(guess)
     # random generators    
@@ -140,6 +156,8 @@ class Cmaes(object):
     #     Individual sigma values - initial search volume. input_sigma determines
     #     the initial coordinate wise standard deviations for the search. Setting
     #     SIGMA one third of the initial search region is appropriate.   
+        if callable(input_sigma):
+            input_sigma=input_sigma()
         if isinstance(input_sigma, list):
             self.insigma = np.asarray(input_sigma)
         elif np.isscalar(input_sigma):
@@ -153,7 +171,7 @@ class Cmaes(object):
         self.max_evaluations = max_evaluations
         self.max_iterations = max_iterations
     # Limit for fitness value.
-        self.stop_fitness = stop_fittness
+        self.stop_fitness = stop_fitness
     # Stop if x-changes larger stopTolUpX.
         self.stopTolUpX = 1e3 * self.sigma
     # Stop if x-change smaller stopTolX.
@@ -165,6 +183,12 @@ class Cmaes(object):
     # selection strategy parameters
     # Number of parents/points for recombination.
         self.mu = int(self.popsize/2)
+    # timing / global best value    
+        if is_debug_active():
+            self.best_y = mp.RawValue(ct.c_double, 1E99)
+            self.n_evals = mp.RawValue(ct.c_long, 0)
+            self.time_0 = time()
+            
     # Array for weighted recombination.    
         self.weights = (np.log(np.arange(1, self.mu+1, 1)) * -1) + math.log(self.mu + 0.5)
         sumw = np.sum(self.weights)
@@ -190,6 +214,9 @@ class Cmaes(object):
         self.chiN = math.sqrt(self.dim) * (1. - 1. / (4. * self.dim) + 1 / (21. * self.dim * self.dim))
         self.ccov1Sep = min(1., self.ccov1 * (self.dim + 1.5) / 3.)
         self.ccovmuSep = min(1. - self.ccov1, self.ccovmu * (self.dim + 1.5) / 3.)        
+    # lazy covariance update gap
+        self.lazy_update_gap = 1. / (self.ccov1 + self.ccovmu + 1e-23) / self.dim / 10 \
+                                    if update_gap is None else update_gap
 
     # CMA internal values - updated each generation
     # Objective variables.
@@ -215,6 +242,7 @@ class Cmaes(object):
         self.historySize = 10 + int(3. * 10. * self.dim / popsize)    
         
         self.iterations = 0
+        self.last_update = 0
         self.stop = 0
         self.best_value = sys.float_info.max
         self.best_x = None    
@@ -222,9 +250,9 @@ class Cmaes(object):
         self.fitness_history = np.full(self.historySize, sys.float_info.max)
         self.fitness_history[0] = self.best_value    
         self.arz = None
+        self.fitness = None
 
-
-    def ask(self):
+    def ask(self) -> np.array:
         """ask for popsize new argument vectors.
             
         Returns
@@ -232,9 +260,11 @@ class Cmaes(object):
         xs : popsize sized list of dim sized argument lists."""
 
         self.newArgs()
-        return [self.fitfun.decode(x) for x in self.arx]
+        return np.array([self.fitfun.decode(x) for x in self.arx])
  
-    def tell(self, ys, xs = None):      
+    def tell(self, 
+             ys: np.ndarray, 
+             xs: Optional[np.ndarray] = None) -> int:      
         """tell function values for the argument lists retrieved by ask().
     
         Parameters
@@ -264,15 +294,106 @@ class Cmaes(object):
         self.updateCMA()
         self.arz = None
         return self.stop
-            
+    
+    def population(self) -> np.array:
+        return self.fitfun.decode(self.arx)
+
+    def result(self) -> OptimizeResult:
+        return OptimizeResult(x=self.best_x, fun=self.best_value, 
+                              nfev=self.fitfun.evaluation_counter, 
+                              nit=self.iterations, status=self.stop, success=True)
+        
+    def ask_one(self) -> np.array:
+        """ask for one new argument vector.
+        
+        Returns
+        -------
+        x : dim sized argument ."""
+        arz = self.randn(self.dim) 
+        delta = (self.BD @ arz.transpose()) * self.sigma
+        arx = self.fitfun.closestFeasible(self.xmean + delta.transpose())  
+        return self.fitfun.decode(arx)
+
+    def tell_one(self,
+                 y: float, 
+                 x: np.array) -> int:      
+        """tell function value for a argument list retrieved by ask_one().
+    
+        Parameters
+        ----------
+        y : function value
+        x : dim sized argument list
+ 
+        Returns
+        -------
+        stop : int termination criteria, if != 0 loop should stop."""
+
+        if self.fitness is None or not type(self.fitness) is list:
+            self.arx = []
+            self.fitness = []
+        self.fitness.append(y)
+        self.arx.append(x)
+        if len(self.fitness) >= self.popsize:
+            self.fitness = np.asarray(self.fitness)
+            self.arx = np.array([self.fitfun.encode(x) for x in self.arx])
+            try:
+                self.arz = (linalg.inv(self.BD) @ \
+                            ((self.arx - self.xmean).transpose() / self.sigma)).transpose()   
+            except Exception:
+                if self.arz is None: 
+                    self.arz = self.randn(self.popsize, self.dim)
+            self.iterations += 1
+            self.updateCMA()
+            self.arz = None
+            self.arx = []
+            self.fitness = []
+        
+        if is_debug_active():
+            self.n_evals.value += 1
+            if y < self.best_y.value or self.n_evals.value % 1000 == 999:           
+                if y < self.best_y.value: self.best_y.value = y
+                t = time() - self.time_0
+                c = self.n_evals.value
+                message = '"c/t={0:.2f} c={1:d} t={2:.2f} y={3:.5f} yb={4:.5f} x={5!s}'.format(
+                    c/t, c, t, y, self.best_y.value, x)
+                logger.debug(message)
+        return self.stop                
+           
     def newArgs(self):
-        self.xmean = self.fitfun.closestFeasible(self.xmean)
-        self.fitness = np.full(self.popsize, math.inf)
         # generate random offspring
         self.arz = self.randn(self.popsize, self.dim)    
         delta = (self.BD @ self.arz.transpose()) * self.sigma
         self.arx = self.fitfun.closestFeasible(self.xmean + delta.transpose())  
-          
+    
+    def do_optimize_delayed_update(self, fun, max_evals=None, workers=mp.cpu_count()):
+        if not max_evals is None: 
+            self.max_evaluations =  max_evals
+        evaluator = Evaluator(fun)
+        evaluator.start(workers)
+        evals_x = {}
+        self.evals = 0;
+        for _ in range(workers): # fill queue
+            x = self.ask_one()
+            evaluator.pipe[0].send((self.evals, x))
+            evals_x[self.evals] = x # store x
+            self.evals += 1
+            
+        while True: # read from pipe, tell es and create new x
+            evals, y = evaluator.pipe[0].recv()
+            
+            x = evals_x[evals] # retrieve evaluated x
+            del evals_x[evals]
+            stop = self.tell_one(y, x) # tell evaluated x
+            if stop != 0 or self.evals >= self.max_evaluations:
+                break # shutdown worker if stop criteria met
+            
+            x = self.ask_one() # create new x
+            evaluator.pipe[0].send((self.evals, x))       
+            evals_x[self.evals] = x  # store x
+            self.evals += 1            
+        evaluator.stop()
+        return self.best_x, self.best_value, evals, self.iterations, self.stop 
+         
     def doOptimize(self):
         # -------------------- Generation Loop --------------------------------
         while True:
@@ -281,10 +402,9 @@ class Cmaes(object):
             self.iterations += 1
             if self.fitfun.evaluation_counter > self.max_evaluations:
                 break
-            # Generate and evaluate popsize offspring
-            self.newArgs()            
-            self.fitness = self.fitfun.values(self.arx)
-            self.updateCMA()
+            xs = self.ask()
+            ys = self.fitfun.values(xs)
+            self.tell(ys, xs)
             if self.stop != 0:
                 break
         return self.best_x, self.best_value, self.fitfun.evaluation_counter, self.iterations, self.stop 
@@ -300,6 +420,9 @@ class Cmaes(object):
         if self.best_value > best_fitness:
             self.best_value = best_fitness
             self.best_x = self.fitfun.decode(self.arx[arindex[0]])    
+            if best_fitness < self.stop_fitness:
+                self.stop = 1
+                return 
 
         # Calculate new xmean, this is selection and recombination
         xold = self.xmean # for speed up of Eq. (2) and (3)
@@ -309,30 +432,29 @@ class Cmaes(object):
         bestArz = self.arz[bestIndex]
         zmean = np.transpose(bestArz) @ self.weights
         hsig = self.updateEvolutionPaths(zmean, xold)            
-        negccov = self.updateCovariance(hsig, bestArx, self.arz, arindex, xold)
-        self.updateBD(negccov)                        
         # Adapt step size sigma - Eq. (5)
         self.sigma *= math.exp(min(1.0, (self.normps / self.chiN - 1.) * self.cs / self.damps))            
-        # handle termination criteria
-        if self.stop_fitness != None: # only if stop_fitness is defined
-            if best_fitness < self.stop_fitness:
-                self.stop = 1
-                return
-        sqrtDiagC = np.sqrt(np.abs(self.diagC))
-        pcCol = self.pc
-        for i in range(self.dim):
-            if self.sigma * max(abs(pcCol[i]), sqrtDiagC[i]) > self.stopTolX:
-                break
-            if i == self.dim - 1:
-                self.stop = 2
-        if self.stop != 0:
-            return            
-        for i in range(self.dim):
-            if self.sigma * sqrtDiagC[i] > self.stopTolUpX:
-                self.stop = 3
-                break
-        if self.stop != 0:
-            return 
+        
+        if self.iterations >= self.last_update + self.lazy_update_gap:
+            self.last_update = self.iterations
+            negccov = self.updateCovariance(hsig, bestArx, self.arz, arindex, xold)
+            self.updateBD(negccov)                        
+            # handle termination criteria
+            sqrtDiagC = np.sqrt(np.abs(self.diagC))
+            pcCol = self.pc
+            for i in range(self.dim):
+                if self.sigma * max(abs(pcCol[i]), sqrtDiagC[i]) > self.stopTolX:
+                    break
+                if i == self.dim - 1:
+                    self.stop = 2
+            if self.stop != 0:
+                return            
+            for i in range(self.dim):
+                if self.sigma * sqrtDiagC[i] > self.stopTolUpX:
+                    self.stop = 3
+                    break
+            if self.stop != 0:
+                return 
         history_best = min(self.fitness_history)
         history_worst = max(self.fitness_history)
         if self.iterations > 2 and max(history_worst, worstFitness) - min(history_best, best_fitness) < self.stopTolFun:
@@ -472,95 +594,4 @@ class Cmaes(object):
             self.diagD = np.sqrt(self.diagD) # diagD contains standard deviations now
             
             self.BD = self.B * self.diagD # O(n^2)
-
-def serial(fun):
-    """Convert an objective function for serial execution for cmaes.minimize.
-    
-    Parameters
-    ----------
-    fun : objective function mapping a list of float arguments to a float value
-
-    Returns
-    -------
-    out : function
-        A function mapping a list of lists of float arguments to a list of float values
-        by applying the input function in a loop."""
-  
-    return lambda xs : [_tryfun(fun, x) for x in xs]
-
-class parallel(object):
-    """Convert an objective function for parallel execution for cmaes.minimize.
-    
-    Parameters
-    ----------
-    fun : objective function mapping a list of float arguments to a float value.
-   
-    represents a function mapping a list of lists of float arguments to a list of float values
-    by applying the input function using parallel processes. stop needs to be called to avoid
-    a resource leak"""
-        
-    def __init__(self, fun, workers):
-        self.evaluator = Evaluator(fun)
-        self.evaluator.start(workers)
-    
-    def __call__(self, xs):
-        return eval_parallel(xs, self.evaluator)
-
-    def stop(self):
-        self.evaluator.stop()
-        
-def _func_serial(fun, num, pid, xs, ys):
-    for i in range(pid, len(xs), num):
-        ys[i] = _tryfun(fun, xs[i])
-
-def _tryfun(fun, x):
-    try:
-        fit = fun(x)
-        return fit if math.isfinite(fit) else sys.float_info.max
-    except Exception:
-        return sys.float_info.max
-                        
-def _check_bounds(bounds, guess, rg):
-    if bounds is None and guess is None:
-        raise ValueError('either guess or bounds need to be defined')
-    if bounds is None:
-        return None, None, np.asarray(guess)
-    if guess is None:
-        guess = rg.uniform(bounds.lb, bounds.ub)
-    return np.asarray(bounds.lb), np.asarray(bounds.ub), np.asarray(guess)
-
-class _Fittness(object):
-    """wrapper around the objective function, scales relative to boundaries."""
-     
-    def __init__(self, fun, lower, upper):
-        self.fun = fun
-        self.evaluation_counter = 0
-        self.lower = lower
-        if not lower is None:
-            self.upper = upper
-            self.scale = 0.5 * (upper - lower)
-            self.typx = 0.5 * (upper + lower)
-                
-    def values(self, Xs): #enables parallel evaluation
-        values = self.fun([self.decode(X) for X in Xs])
-        self.evaluation_counter += len(Xs)
-        return np.array(values)
-
-    def closestFeasible(self, X):
-        if self.lower is None:
-            return X    
-        else:
-            return np.maximum(np.minimum(X, 1.0), -1.0)
-
-    def encode(self, X):
-        if self.lower is None:
-            return X
-        else:
-            return (X - self.typx) / self.scale
-    
-    def decode(self, X):
-        if self.lower is None:
-            return X
-        else:
-            return (X * self.scale) + self.typx
-    
+