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

fcmaes/retry.py

@@ -2,48 +2,52 @@
 #
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory.
+from __future__ import annotations
 
-import random
 import time
 import math
 import os
 import sys
+import threadpoolctl
 import ctypes as ct
+from scipy import interpolate
 import numpy as np
-from numpy.random import Generator, MT19937, SeedSequence
+from numpy.random import Generator, PCG64DXSM, SeedSequence
 from scipy.optimize._constraints import new_bounds_to_old
 from scipy.optimize import OptimizeResult, Bounds
 import multiprocessing as mp
 from multiprocessing import Process
-from fcmaes.optimizer import de_cma, dtime, logger
+from fcmaes.optimizer import de_cma, dtime, Optimizer
+from fcmaes.evaluator import is_debug_active, is_trace_active
+from loguru import logger
+from typing import Optional, Callable, List
+from numpy.typing import ArrayLike
 
 os.environ['MKL_DEBUG_CPU_TYPE'] = '5'
 os.environ['MKL_NUM_THREADS'] = '1'
 os.environ['OPENBLAS_NUM_THREADS'] = '1'
 
-def minimize(fun, 
-             bounds = None, 
-             value_limit = math.inf,
-             num_retries = 1000,
-             logger = None,
-             workers = mp.cpu_count(),
-             popsize = 31, 
-             max_evaluations = 50000, 
-             capacity = 500,
-             stop_fittness = None,
-             optimizer = None,
-             ):   
+def minimize(fun: Callable[[ArrayLike], float], 
+             bounds: Bounds, 
+             value_limit: Optional[float] = np.inf,
+             num_retries: Optional[int] = 1024,
+             workers: Optional[int] = mp.cpu_count(),
+             popsize: Optional[int] = 31, 
+             max_evaluations: Optional[int] = 50000, 
+             capacity: Optional[int] = 500,
+             stop_fitness: Optional[float] = -np.inf,
+             optimizer: Optional[Optimizer] = None,
+             statistic_num: Optional[int] = 0,
+             ) -> OptimizeResult:   
     """Minimization of a scalar function of one or more variables using parallel 
-     CMA-ES retry.
+     optimization retry.
      
     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.
@@ -53,10 +57,6 @@ def minimize(fun,
         Upper limit for optimized function values to be stored. 
     num_retries : int, optional
         Number of optimization retries.    
-    logger : logger, optional
-        logger for log output of the retry mechanism. If None, logging
-        is switched off. Default is a logger which logs both to stdout and
-        appends to a file ``optimizer.log``.
     workers : int, optional
         number of parallel processes used. Default is mp.cpu_count()
     popsize = int, optional
@@ -69,10 +69,12 @@ def minimize(fun,
         this setting is defined in the optimizer. 
     capacity : int, optional
         capacity of the evaluation store.
-    stop_fittness : float, optional 
+    stop_fitness : float, optional 
          Limit for fitness value. optimization runs terminate if this value is reached. 
     optimizer : optimizer.Optimizer, optional
         optimizer to use. Default is a sequence of differential evolution and CMA-ES.
+    statistic_num: int, optional
+        if > 0 stores the progress of the optimization. Defines the size of this store. 
      
     Returns
     -------
@@ -83,33 +85,151 @@ def minimize(fun,
         ``success`` a Boolean flag indicating if the optimizer exited successfully. """
 
     if optimizer is None:
-        optimizer = de_cma(max_evaluations, popsize, stop_fittness)        
-    store = Store(bounds, capacity = capacity, logger = logger)
-    return retry(fun, store, optimizer.minimize, num_retries, value_limit, workers)
-                 
-def retry(fun, store, optimize, num_retries, value_limit = math.inf, workers=mp.cpu_count()):
+        optimizer = de_cma(max_evaluations, popsize, stop_fitness)        
+    store = Store(fun, bounds, capacity = capacity, statistic_num = statistic_num)
+    return retry(store, optimizer.minimize, num_retries, value_limit, workers, stop_fitness)
+
+def retry(store: Store, 
+          optimize: Callable, 
+          num_retries: int, 
+          value_limit: Optional[float] = np.inf, 
+          workers: Optional[int] = mp.cpu_count(), 
+          stop_fitness: Optional[float] = -np.inf) -> OptimizeResult:
+    
     sg = SeedSequence()
-    rgs = [Generator(MT19937(s)) for s in sg.spawn(workers)]
+    rgs = [Generator(PCG64DXSM(s)) for s in sg.spawn(workers)]
     proc=[Process(target=_retry_loop,
-            args=(pid, rgs, fun, store, optimize, num_retries, value_limit)) for pid in range(workers)]
+            args=(pid, rgs, store, optimize, num_retries, value_limit, stop_fitness)) for pid in range(workers)]
     [p.start() for p in proc]
     [p.join() for p in proc]
     store.sort()
     store.dump()
     return OptimizeResult(x=store.get_x_best(), fun=store.get_y_best(), 
                           nfev=store.get_count_evals(), success=True)
+
+def minimize_plot(name: str, 
+                  optimizer: Optimizer, 
+                  fun: Callable[[ArrayLike], float], 
+                  bounds: Bounds, 
+                  value_limit: Optional[float] = np.inf, 
+                  plot_limit: Optional[float] = np.inf, 
+                  num_retries: Optional[int] = 1024, 
+                  workers: Optional[int] = mp.cpu_count(), 
+                  stop_fitness: Optional[float] = -np.inf, 
+                  statistic_num: Optional[int] = 5000) -> OptimizeResult:
+    
+    time0 = time.perf_counter() # optimization start time
+    name += '_' + optimizer.name
+    logger.info('optimize ' + name)       
+    store = Store(fun, bounds, capacity = 500, statistic_num = statistic_num)
+    ret = retry(store, optimizer.minimize, num_retries, value_limit, workers, stop_fitness)
+    impr = store.get_improvements()
+    np.savez_compressed(name, ys=impr)
+    for _ in range(10):
+        filtered = np.array([imp for imp in impr if imp[1] < plot_limit])
+        if len(filtered) > 0: 
+            impr = filtered
+            break
+        else:
+            plot_limit *= 3
+    logger.info(name + ' time ' + str(dtime(time0))) 
+    plot(impr, 'progress_ret.' + name + '.png', label = name, 
+         xlabel = 'time in sec', ylabel = r'$f$')
+    return ret
+
+def plot(front: ArrayLike, fname: str, interp: Optional[bool] = True, 
+         label: Optional[str] = r'$\chi$', 
+         xlabel: Optional[str] = r'$f_1$', ylabel:Optional[str] = r'$f_2$', 
+         zlabel: Optional[str] = r'$f_3$', plot3d: Optional[bool] = False, 
+         s = 1, dpi=300):
+    if len(front[0]) == 3 and plot3d:
+        plot3(front, fname, label, xlabel, ylabel, zlabel)
+        return
+    if len(front[0]) >= 3:
+        for i in range(1, len(front[0])):
+            plot(front.T[np.array([0,i])].T, str(i) + '_' + fname, 
+                 interp=interp, ylabel = r'$f_{0}$'.format(i+1))     
+        return   
+    if len(front[0]) == 1:
+        ys = np.array(list(zip(range(100), [front[0][0]]*100)))
+        plot(ys, str(1) + '_' + fname, 
+                 interp=interp, xlabel = '', ylabel = r'$f_{0}$'.format(1))     
+        return      
+    import matplotlib.pyplot as pl
+    fig, ax = pl.subplots(1, 1)
+    x = front[:, 0]; y = front[:, 1]
+    if interp and len(x) > 2:
+        xa = np.argsort(x)
+        xs = x[xa]; ys = y[xa]
+        x = []; y = []
+        for i in range(len(xs)): # filter equal x values
+            if i == 0 or xs[i] > xs[i-1] + 1E-5:
+                x.append(xs[i]); y.append(ys[i])
+        tck = interpolate.InterpolatedUnivariateSpline(x,y,k=1)
+        x = np.linspace(min(x),max(x),1000)
+        y = [tck(xi) for xi in x]
+    ax.scatter(x, y, label=label, s=s)
+    ax.grid()
+    ax.set_xlabel(xlabel)
+    ax.set_ylabel(ylabel)
+    ax.legend()
+    fig.savefig(fname, dpi=dpi)
+    pl.close('all')
+
+def plot3(front: ArrayLike, fname: str, label: Optional[str] =r'$\chi$', 
+         xlabel: Optional[str] = r'$f_1$', ylabel: Optional[str] = r'$f_2$', 
+         zlabel: Optional[str] = r'$f_3$'):
+    import matplotlib.pyplot as pl
+    fig = pl.figure()
+    ax = fig.add_subplot(projection='3d')
+    x = front[:, 0]; y = front[:, 1]; z = front[:, 2]
+    ax.scatter(x, y, z, label=label, s=1)
+    ax.grid()
+    ax.set_xlabel(xlabel)
+    ax.set_ylabel(ylabel)
+    ax.set_zlabel(zlabel)
+    ax.legend()
+    #pl.show()
+    fig.savefig(fname, dpi=300)
+    pl.close('all')
+
+
+dtype_map = {
+    'int32': ct.c_int32,
+    'int64': ct.c_int64,
+    'float32': ct.c_float,
+    'float64': ct.c_double,
+}
+    
+class Shared2d():
+    
+    def __init__(self, xs):
+        self.rows, self.cols = xs.shape     
+        self.dtype = xs.dtype
+        self.ra = mp.RawArray(dtype_map[str(xs.dtype)], self.rows*self.cols)       
+        self.set(xs)
+        
+    def set_i(self, i, x):
+        self.view()[i, :] = x
+    
+    def view(self):
+        return np.frombuffer(self.ra, dtype=self.dtype).reshape((self.rows, self.cols))
+        
+    def set(self, xs):
+        np.copyto(self.view(), xs)      
  
 class Store(object):
     """thread safe storage for optimization retry results."""
        
     def __init__(self, 
-                 bounds, # bounds of the objective function arguments
-                 check_interval = 10, # sort evaluation memory after check_interval iterations
-                 capacity = 500, # capacity of the evaluation store
-                 logger = None # if None logging is switched off
+                 fun: Callable[[ArrayLike], float], # fitness function
+                 bounds: Bounds, # bounds of the objective function arguments
+                 check_interval: Optional[int] = 10, # sort evaluation memory after check_interval iterations
+                 capacity: Optional[int] = 500, # capacity of the evaluation store
+                 statistic_num: Optional[int] = 0
                 ):    
+        self.fun = fun
         self.lower, self.upper = _convertBounds(bounds)
-        self.logger = logger
         self.capacity = capacity
         self.check_interval = check_interval
         self.dim = len(self.lower)
@@ -119,131 +239,142 @@ class Store(object):
         
         #shared between processes
         self.add_mutex = mp.Lock()    
-        self.xs = mp.RawArray(ct.c_double, self.capacity * self.dim)
+        self.xs = Shared2d(np.empty((self.capacity, self.dim), dtype = np.float64))
+        self.create_xs_view()
         self.ys = mp.RawArray(ct.c_double, self.capacity)  
         self.count_evals = mp.RawValue(ct.c_long, 0)   
         self.count_runs = mp.RawValue(ct.c_int, 0) 
-        self.num_stored = mp.RawValue(ct.c_int, 0) 
-        self.num_sorted = mp.RawValue(ct.c_int, 0)  
+        self.num_stored = mp.RawValue(ct.c_int, 0)   
         self.count_stat_runs = mp.RawValue(ct.c_int, 0)  
         self.t0 = time.perf_counter()
         self.mean = mp.RawValue(ct.c_double, 0) 
         self.qmean = mp.RawValue(ct.c_double, 0) 
-        self.best_y = mp.RawValue(ct.c_double, math.inf) 
+        self.best_y = mp.RawValue(ct.c_double, np.inf) 
         self.best_x = mp.RawArray(ct.c_double, self.dim)
-        # statistics                            
-        self.statistic_num = 1000
-        self.time = mp.RawArray(ct.c_double, self.statistic_num)
-        self.val = mp.RawArray(ct.c_double, self.statistic_num)
-        self.si = mp.RawValue(ct.c_int, 0)
+        self.statistic_num = statistic_num
+        # statistics   
+        self.statistic_num = statistic_num                         
+        if statistic_num > 0:  # enable statistics                          
+            self.time = mp.RawArray(ct.c_double, self.statistic_num)
+            self.val = mp.RawArray(ct.c_double, self.statistic_num)
+            self.si = mp.RawValue(ct.c_int, 0)
+            self.sevals = mp.RawValue(ct.c_long, 0)
+            self.bval = mp.RawValue(ct.c_double, np.inf)
 
-    # store improvement - time and value
-    def add_statistics(self):
-        si = self.si.value
-        if si < self.statistic_num - 1:
-            self.si.value = si + 1
-        self.time[si] = dtime(self.t0)
-        self.val[si] = self.best_y.value  
-        
+    # register improvement - time and value
+    def wrapper(self, x: ArrayLike):
+        y = self.fun(x)
+        self.sevals.value += 1
+        if y < self.bval.value:
+            self.bval.value = y
+            si = self.si.value
+            if si < self.statistic_num - 1:
+                self.si.value = si + 1
+            self.time[si] = dtime(self.t0)
+            self.val[si] = y  
+            logger.trace(str(self.time[si]) + ' '  + 
+                      str(self.sevals.value) + ' ' + 
+                      str(int(self.sevals.value / self.time[si])) + ' ' + 
+                      str(y) + ' ' + 
+                      str(list(x)))
+        return y
+         
     def get_improvements(self):
-        return zip(self.time[:self.si.value], self.val[:self.si.value])
- 
+        return np.array(list(zip(self.time[:self.si.value], self.val[:self.si.value])))
+        
     # get num best values at evenly distributed times
-    def get_statistics(self, num):
+    def get_statistics(self, num: int) -> List:
         ts = self.time[:self.si.value]
-        vs = self.val[:self.si.value]
+        ys = self.val[:self.si.value]
         mt = ts[-1]
         dt = 0.9999999 * mt / num
         conv = []
         ti = 0
-        val = vs[0]
+        val = ys[0]
         for i in range(num):
             while ts[ti] < (i+1) * dt:
                 ti += 1
-                val = vs[ti]
+                val = ys[ti]
             conv.append(val)
         return conv
     
-    def eval_num(self, max_evals):
+    def eval_num(self, max_evals: int) -> int:
         return max_evals
                                              
-    def replace(self, i, y, xs):
+    def replace(self, i: int, y: float, xs: ArrayLike):
         self.set_y(i, y)
         self.set_x(i, xs)
              
-    def sort(self): # sort all entries to make room for new ones, determine best and worst
+    def sort(self) -> int: # sort all entries to make room for new ones, determine best and worst
         """sorts all store entries, keep only the 90% best to make room for new ones."""
         ns = self.num_stored.value
         ys = np.asarray(self.ys[:ns])
         yi = ys.argsort()
-        sortRuns = []
-        for i in range(len(yi)):
-            y = ys[yi[i]]
-            xs = self.get_x(yi[i])
-            sortRuns.append((y, xs))
-        numStored = min(len(sortRuns),int(0.9*self.capacity)) # keep 90% best 
-        for i in range(numStored):
-            self.replace(i, sortRuns[i][0], sortRuns[i][1])
-        self.num_sorted.value = numStored  
+        numStored = min(ns, int(0.9*self.capacity)) # keep 90% best 
+        self.xs_view[:numStored] = self.xs_view[yi][:numStored]
+        self.ys[:numStored] = ys[yi][:numStored]
         self.num_stored.value = numStored  
         return numStored        
             
-    def add_result(self, y, xs, evals, limit=math.inf):
-        """registers an optimization result at the score."""
+    def add_result(self, y: float, x: ArrayLike, evals: int, limit=np.inf):
+        """registers an optimization result at the store."""
         with self.add_mutex:
             self.incr_count_evals(evals)
             if y < limit:  
                 self.count_stat_runs.value += 1
                 if y < self.best_y.value:
                     self.best_y.value = y
-                    self.best_x[:] = xs[:]
-                    self.add_statistics()
+                    self.best_x[:] = x[:]
                     self.dump()
                 if self.num_stored.value >= self.capacity-1:
                     self.sort()
                 cnt = self.count_stat_runs.value
-                diff = y - self.mean.value
-                self.qmean.value += (cnt - 1) * diff*diff / cnt;
+                diff = min(1E20, y - self.mean.value) # avoid overflow
+                self.qmean.value += (cnt - 1)/ cnt * diff*diff ;
                 self.mean.value += diff / cnt
                 ns = self.num_stored.value
                 self.num_stored.value = ns + 1
-                self.replace(ns, y, xs)
-            
-    def get_x(self, pid):
-        return self.xs[pid*self.dim:(pid+1)*self.dim]
+                self.xs_view[self.num_stored.value, :] = x
+                self.ys[self.num_stored.value] = y
+                if is_debug_active():
+                    dt = dtime(self.t0)  
+                    message = '{0} {1} {2} {3} {4:.6f} {5:.6f} {6:.2f} {7:.2f}'.format(
+                        dt, int(self.count_evals.value / dt), self.count_runs.value, self.count_evals.value, \
+                        y, self.best_y.value, self.get_y_mean(), self.get_y_standard_dev())
+                    logger.debug(message)
 
-    def get_x_best(self):
-        return self.best_x[:]
+    def get_x_best(self) -> np.ndarray:
+        return np.array(self.best_x[:])
     
-    def get_y(self, pid):
+    def create_xs_view(self): # needs to be called in the target process
+        self.xs_view = self.xs.view()
+ 
+    def get_xs(self) -> np.ndarray:
+        return self.xs.view()[:self.num_stored.value]
+        
+    def get_y(self, pid: int) -> float:
         return self.ys[pid]
 
-    def get_y_best(self):
+    def get_y_best(self) -> float:
         return self.best_y.value
     
-    def get_ys(self):
-        return self.ys[:self.num_stored.value]
+    def get_ys(self) -> np.ndarray:
+        return np.array(self.ys[:self.num_stored.value])
              
-    def get_y_mean(self):
+    def get_y_mean(self) -> float:
         return self.mean.value
 
-    def get_y_standard_dev(self):
-        cnt = self.get_count_runs()
+    def get_y_standard_dev(self) -> float:
+        cnt = self.count_stat_runs.value
         return 0 if cnt <= 0 else math.sqrt(self.qmean.value / cnt)
 
-    def get_count_evals(self):
+    def get_count_evals(self) -> int:
         return self.count_evals.value
  
-    def get_count_runs(self):
+    def get_count_runs(self) -> int:
         return self.count_runs.value
- 
-    def set_x(self, pid, xs):
-        self.xs[pid*self.dim:(pid+1)*self.dim] = xs[:]
-       
-    def set_y(self, pid, y):
-        self.ys[pid] = y    
- 
-    def get_runs_compare_incr(self, limit):
+
+    def get_runs_compare_incr(self, limit: float):
         with self.add_mutex:
             if self.count_runs.value < limit:
                 self.count_runs.value += 1
@@ -258,36 +389,32 @@ class Store(object):
             
     def dump(self):
         """logs the current status of the store if logger defined."""
-        if self.logger is None:
+        if not is_debug_active():
             return
         Ys = self.get_ys()
         vals = []
         for i in range(min(20, len(Ys))):
-            vals.append(round(Ys[i],2))     
-        dt = dtime(self.t0)   
-                 
+            vals.append(round(Ys[i],4))     
+        dt = dtime(self.t0)                   
         message = '{0} {1} {2} {3} {4:.6f} {5:.2f} {6:.2f} {7!s} {8!s}'.format(
             dt, int(self.count_evals.value / dt), self.count_runs.value, self.count_evals.value, \
                 self.best_y.value, self.get_y_mean(), self.get_y_standard_dev(), vals, self.best_x[:])
-        self.logger.info(message)
+        logger.debug(message)
 
         
-def _retry_loop(pid, rgs, fun, store, optimize, num_retries, value_limit):
-    
-    #reinitialize logging config for windows -  multi threading fix
-    if 'win' in sys.platform and not store.logger is None:
-        store.logger = logger()
-        
+def _retry_loop(pid, rgs, store, optimize, num_retries, value_limit, stop_fitness = -np.inf):
+    store.create_xs_view()
+    fun = store.wrapper if store.statistic_num > 0 else store.fun    
     lower = store.lower
-    while store.get_runs_compare_incr(num_retries):        
-        try:       
-            sol, y, evals = optimize(fun, Bounds(store.lower, store.upper), None, 
-                                     [random.uniform(0.05, 0.1)]*len(lower), rgs[pid], store)
-            store.add_result(y, sol, evals, value_limit)           
-        except Exception as ex:
-            continue
-#         if pid == 0:
-#             store.dump()
+    with threadpoolctl.threadpool_limits(limits=1, user_api="blas"):
+        while store.get_runs_compare_incr(num_retries) and store.best_y.value > stop_fitness:      
+            try:       
+                rg = rgs[pid]
+                sol, y, evals = optimize(fun, Bounds(store.lower, store.upper), None, 
+                                         [rg.uniform(0.05, 0.1)]*len(lower), rg, store)
+                store.add_result(y, sol, evals, value_limit)   
+            except Exception as ex:
+                print(str(ex))
 
 def _convertBounds(bounds):
     if bounds is None: