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

fcmaes/de.py

@@ -16,6 +16,19 @@
     You may keep parameters F and Cr at their defaults since this implementation works well with the given settings for most problems,
     since the algorithm oscillates between different F and Cr settings. 
     
+    The filter parameter is inspired by "Surrogate-based Optimisation for a Hospital Simulation"
+    (https://dl.acm.org/doi/10.1145/3449726.3463283) where a machine learning classifier is used to 
+    filter candidate solutions for DE. A filter object needs to provide function add(x, y) to enable learning and
+    a predicate is_improve(x, x_old, y_old) used to decide if function evaluation of x is worth the effort. 
+    
+    The ints parameter is a boolean array indicating which parameters are discrete integer values. This 
+    parameter was introduced after observing non optimal results for the ESP2 benchmark problem: 
+    https://github.com/AlgTUDelft/ExpensiveOptimBenchmark/blob/master/expensiveoptimbenchmark/problems/DockerCFDBenchmark.py
+    If defined it causes a "special treatment" for discrete variables: They are rounded to the next integer value and
+    there is an additional mutation to avoid getting stuck at local minima. This behavior is specified by the internal
+    function _modifier which can be overwritten by providing the optional modifier argument. If modifier is defined,
+    ints is ignored. 
+    
     Use the C++ implementation combined with parallel retry instead for objective functions which are fast to evaluate. 
     For expensive objective functions (e.g. machine learning parameter optimization) use the workers
     parameter to parallelize objective function evaluation. This causes delayed population update.
@@ -26,25 +39,31 @@ import numpy as np
 import math, sys
 from time import time
 import ctypes as ct
-from fcmaes.testfun import Wrapper, Rosen, Rastrigin, Eggholder
-from numpy.random import Generator, MT19937
-from scipy.optimize import OptimizeResult
-from fcmaes.evaluator import Evaluator
+from numpy.random import Generator, PCG64DXSM
+from scipy.optimize import OptimizeResult, Bounds
+from fcmaes.evaluator import Evaluator, is_debug_active
 import multiprocessing as mp
 from collections import deque
+from loguru import logger
+from typing import Optional, Callable, Tuple, Union
+from numpy.typing import ArrayLike
 
-def minimize(fun, 
-             dim = None,
-             bounds = None, 
-             popsize = 31, 
-             max_evaluations = 100000, 
-             workers = None,
-             stop_fitness = None, 
-             keep = 200, 
-             f = 0.5, 
-             cr = 0.9, 
-             rg = Generator(MT19937()),
-             logger = None):    
+def minimize(fun: Callable[[ArrayLike], float], 
+             dim: Optional[int] = None,
+             bounds: Optional[Bounds] = None,
+             popsize: Optional[int] = 31,
+             max_evaluations: Optional[int] = 100000,
+             workers: Optional[int] = None,
+             stop_fitness: Optional[float] = -np.inf,
+             keep: Optional[int] = 200,
+             f: Optional[float] = 0.5,
+             cr: Optional[float] = 0.9,
+             rg: Optional[Generator] = Generator(PCG64DXSM()),
+             filter = None,
+             ints: Optional[ArrayLike] = None,
+             min_mutate: Optional[float] = 0.1,
+             max_mutate: Optional[float] = 0.5,
+             modifier: Optional[Callable] = None) -> OptimizeResult: 
     """Minimization of a scalar function of one or more variables using
     Differential Evolution.
      
@@ -52,10 +71,8 @@ def minimize(fun,
     ----------
     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,)
     dim : int
         dimension of the argument of the objective function
         either dim or bounds need to be defined
@@ -84,10 +101,21 @@ def minimize(fun,
         In the literature this is also known as the crossover probability.     
     rg = numpy.random.Generator, optional
         Random generator for creating random guesses.
-    logger : logger, optional
-        logger for log output for tell_one, If None, logging
-        is switched off. Default is a logger which logs both to stdout and
-        appends to a file ``optimizer.log``.
+    filter = filter object, optional 
+        needs to provide function add(x, y) and predicate is_improve(x, x_old, y_old).
+        used to decide if function evaluation of x is worth the effort. 
+        Either f(x) < f(x_old) or f(x) < y_old need to be approximated.     
+        add(x, y) can be used to learn from past results.
+    ints = list or array of bool, optional
+        indicating which parameters are discrete integer values. If defined these parameters will be
+        rounded to the next integer and some additional mutation of discrete parameters are performed.    
+    min_mutate = float, optional
+        Determines the minimal mutation rate for discrete integer parameters.
+    max_mutate = float, optional
+        Determines the maximal mutation rate for discrete integer parameters. 
+    modifier = callable, optional
+        used to overwrite the default behaviour induced by ints. If defined, the ints parameter is
+        ignored. Modifies all generated x vectors.
             
     Returns
     -------
@@ -100,7 +128,8 @@ def minimize(fun,
         ``success`` a Boolean flag indicating if the optimizer exited successfully. """
 
     
-    de = DE(dim, bounds, popsize, stop_fitness, keep, f, cr, rg, logger)
+    de = DE(dim, bounds, popsize, stop_fitness, keep, f, cr, rg, filter, ints,  
+            min_mutate, max_mutate, modifier)
     try:
         if workers and workers > 1:
             x, val, evals, iterations, stop = de.do_optimize_delayed_update(fun, max_evaluations, workers)
@@ -113,8 +142,21 @@ def minimize(fun,
 
 class DE(object):
     
-    def __init__(self, dim, bounds, popsize = 31, stop_fitness = None, keep = 200, 
-                 F = 0.5, Cr = 0.9, rg = Generator(MT19937()), logger = None):
+    def __init__(self,
+                dim: int,
+                bounds: Bounds,  
+                popsize: Optional[int] = 31, 
+                stop_fitness: Optional[float] = -np.inf, 
+                keep: Optional[int] = 200, 
+                F: Optional[float] = 0.5, 
+                Cr: Optional[float] = 0.9, 
+                rg: Optional[Generator] = Generator(PCG64DXSM()),
+                filter: Optional = None,
+                ints: Optional[ArrayLike] = None,
+                min_mutate: Optional[float] = 0.1,
+                max_mutate: Optional[float] = 0.5, 
+                modifier: Optional[Callable] = None):    
+        
         self.dim, self.lower, self.upper = _check_bounds(bounds, dim)
         if popsize is None:
             popsize = 31
@@ -129,14 +171,24 @@ class DE(object):
         self.evals = 0
         self.p = 0
         self.improves = deque()
-        self._init()
-        if not logger is None:
-            self.logger = logger
+        self.filter = filter
+        self.ints = np.array(ints)
+        self.min_mutate = min_mutate
+        self.max_mutate = max_mutate 
+        # use default variable modifier for int variables if modifier is None
+        if modifier is None and not ints is None:
+            self.lower = self.lower.astype(float)
+            self.upper = self.upper.astype(float)
+            self.modifier = self._modifier
+        else:
+            self.modifier = modifier
+        self._init()                     
+        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()
-        
-    def ask(self):
+     
+    def ask(self) -> np.ndarray:
         """ask for popsize new argument vectors.
             
         Returns
@@ -144,7 +196,7 @@ class DE(object):
         xs : popsize sized array of dim sized argument lists."""
         
         xs = [None] * self.popsize
-        for i in range(self.popsize):
+        for _ in range(self.popsize):
             if self.improves:
                 p, x = self.improves[0]
                 if xs[p] is None:
@@ -157,9 +209,13 @@ class DE(object):
         for p in range(self.popsize):
             if xs[p] is None:
                 _, _, xs[p] = self._next_x(p)      
+        self.asked = xs      
         return xs
  
-    def tell(self, ys, xs):      
+    def tell(self, 
+             ys:ArrayLike, 
+             xs:Optional[ArrayLike] = None) -> int:
+              
         """tell function values for the argument lists retrieved by ask().
     
         Parameters
@@ -171,12 +227,22 @@ class DE(object):
         -------
         stop : int termination criteria, if != 0 loop should stop."""
 
+        if xs is None:
+            xs = self.asked
         self.evals += len(ys)
         for p in range(len(ys)):
             self.tell_one(p, ys[p], xs[p])
         return self.stop
 
-    def ask_one(self):
+    def population(self) -> np.ndarray:
+        return self.x
+
+    def result(self) -> OptimizeResult:
+        return OptimizeResult(x=self.best_x, fun=self.best_value, 
+                              nfev=self.iterations*self.popsize, 
+                              nit=self.iterations, status=self.stop, success=True)
+    
+    def ask_one(self) -> Tuple[int, np.ndarray]:
         """ask for one new argument vector.
         
         Returns
@@ -192,7 +258,7 @@ class DE(object):
             self.p = (self.p + 1) % self.popsize
         return p, x
 
-    def tell_one(self, p, y, x):      
+    def tell_one(self, p: int, y:float , x:ArrayLike) -> int:      
         """tell function value for a argument list retrieved by ask_one().
     
         Parameters
@@ -204,6 +270,9 @@ class DE(object):
         Returns
         -------
         stop : int termination criteria, if != 0 loop should stop."""
+
+        if not self.filter is None:
+            self.filter.add(x, y)
         
         if (self.y[p] > y):
             # temporal locality
@@ -217,23 +286,23 @@ class DE(object):
                 if self.best_value > y:
                     self.best_x = x
                     self.best_value = y
-                    if not self.stop_fitness is None and self.stop_fitness > y:
+                    if self.stop_fitness > y:
                         self.stop = 1
             self.pop_iter[p] = self.iterations
         else:
             if self.rg.uniform(0, self.keep) < self.iterations - self.pop_iter[p]:
                 self.x[p] = self._sample()
-                self.y[p] = math.inf
+                self.y[p] = np.inf
         
-        if hasattr(self, 'logger'):
+        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
+                t = time() - self.time_0 + 1E-9
                 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)
-                self.logger.info(message)
+                logger.debug(message)
 
         return self.stop 
 
@@ -243,12 +312,25 @@ class DE(object):
         self.y = np.empty(self.popsize)
         for i in range(self.popsize):
             self.x[i] = self.x0[i] = self._sample()
-            self.y[i] = math.inf
+            self.y[i] = np.inf
         self.best_x = self.x[0]
-        self.best_value = math.inf
+        self.best_value = np.inf
         self.best_i = 0
         self.pop_iter = np.zeros(self.popsize)
        
+    def apply_fun(self, x, x_old, y_old):
+        if self.filter is None:
+            self.evals += 1
+            return self.fun(x)
+        else:
+            if self.filter.is_improve(x, x_old, y_old):
+                self.evals += 1
+                y = self.fun(x)
+                self.filter.add(x, y)
+                return y
+            else:    
+                return 1E99
+       
     def do_optimize(self, fun, max_evals):
         self.fun = fun
         self.max_evals = max_evals    
@@ -257,14 +339,12 @@ class DE(object):
         while self.evals < self.max_evals:
             for p in range(self.popsize):
                 xb, xi, x = self._next_x(p)
-                y = self.fun(x)
-                self.evals += 1
+                y = self.apply_fun(x, xi, self.y[p])
                 if y < self.y[p]:
                     # temporal locality
                     if self.iterations > 1:
                         x2 = self._next_improve(xb, x, xi)
-                        y2 = self.fun(x2)
-                        self.evals += 1
+                        y2 = self.apply_fun(x2, x, y)
                         if y2 < y:
                             y = y2
                             x = x2
@@ -276,13 +356,13 @@ class DE(object):
                         if y < self.best_value:
                             self.best_value = y;
                             self.best_x = x;
-                            if not self.stop_fitness is None and self.stop_fitness > y:
+                            if self.stop_fitness > y:
                                 self.stop = 1
                 else:
                     # reinitialize individual
                     if self.rg.uniform(0, self.keep) < self.iterations - self.pop_iter[p]:
                         self.x[p] = self._sample()
-                        self.y[p] = math.inf
+                        self.y[p] = np.inf
                 if self.evals >= self.max_evals:
                     break
 
@@ -312,7 +392,11 @@ class DE(object):
             if self.stop != 0 or self.evals >= self.max_evals:
                 break # shutdown worker if stop criteria met
             
-            p, x = self.ask_one() # create new x          
+            for _ in range(workers):
+                p, x = self.ask_one() # create new x          
+                if self.filter is None or \
+                    self.filter.is_improve(x, self.x[p], self.y[p]):
+                        break
             evaluator.pipe[0].send((self.evals, x))       
             evals_x[self.evals] = p, x  # store x
             self.evals += 1
@@ -338,24 +422,45 @@ class DE(object):
         r = self.rg.integers(0, self.dim)
         tr = np.array(
             [i != r and self.rg.random() > self.Cr for i in range(self.dim)])    
-        x[tr] = xp[tr]       
+        x[tr] = xp[tr]  
+        if not self.modifier is None:
+            x = self.modifier(x)
         return xb, xp, x
 
     def _next_improve(self, xb, x, xi):
-        return self._feasible(xb + ((x - xi) * 0.5))
-    
+        x = self._feasible(xb + ((x - xi) * 0.5))
+        if not self.modifier is None:
+            x = self.modifier(x)
+        return x
+            
     def _sample(self):
         if self.upper is None:
             return self.rg.normal()
         else:
-            return self.rg.uniform(self.lower, self.upper)
+            x = self.rg.uniform(self.lower, self.upper)
+            if not self.modifier is None:
+                x = self.modifier(x)
+            return x
     
     def _feasible(self, x):
         if self.upper is None:
             return x
         else:
-            return np.maximum(np.minimum(x, self.upper), self.lower)
-                
+            return np.clip(x, self.lower, self.upper)
+    
+    # default modifier for integer variables
+    def _modifier(self, x):
+        x_ints = x[self.ints]
+        n_ints = len(self.ints)
+        lb = self.lower[self.ints]
+        ub = self.upper[self.ints]
+        to_mutate = self.rg.uniform(self.min_mutate, self.max_mutate)
+        # mututate some integer variables
+        x[self.ints] = np.array([x if self.rg.random() > to_mutate/n_ints else 
+                           int(self.rg.uniform(lb[i], ub[i]))
+                           for i, x in enumerate(x_ints)])
+        return x   
+                        
 def _check_bounds(bounds, dim):
     if bounds is None and dim is None:
         raise ValueError('either dim or bounds need to be defined')
@@ -363,3 +468,5 @@ def _check_bounds(bounds, dim):
         return dim, None, None
     else:
         return len(bounds.ub), np.asarray(bounds.lb), np.asarray(bounds.ub)
+    
+