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

fcmaes/retry.py

@@ -2,40 +2,43 @@
 #
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory.
+from __future__ import annotations
 
 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 = 1024,
-             logger = None,
-             workers = mp.cpu_count(),
-             popsize = 31, 
-             max_evaluations = 50000, 
-             capacity = 500,
-             stop_fitness = -math.inf,
-             optimizer = None,
-             statistic_num = 0,
-             plot_name = 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 
      optimization retry.
      
@@ -43,10 +46,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,)
     bounds : sequence or `Bounds`, optional
         Bounds on variables. There are two ways to specify the bounds:
             1. Instance of the `scipy.Bounds` class.
@@ -56,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
@@ -78,10 +75,6 @@ def minimize(fun,
         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. 
-    plot_name : String, optional
-        if defined plots are generated during the optimization to monitor progress.
-        Requires statistic_num > 100.
-
      
     Returns
     -------
@@ -93,14 +86,18 @@ def minimize(fun,
 
     if optimizer is None:
         optimizer = de_cma(max_evaluations, popsize, stop_fitness)        
-    store = Store(fun, bounds, capacity = capacity, logger = logger, statistic_num = statistic_num, 
-                  plot_name = plot_name)
+    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, optimize, num_retries, value_limit = math.inf, 
-          workers=mp.cpu_count(), stop_fitness = -math.inf):
+
+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, store, optimize, num_retries, value_limit, stop_fitness)) for pid in range(workers)]
     [p.start() for p in proc]
@@ -110,27 +107,41 @@ def retry(store, optimize, num_retries, value_limit = math.inf,
     return OptimizeResult(x=store.get_x_best(), fun=store.get_y_best(), 
                           nfev=store.get_count_evals(), success=True)
 
-def minimize_plot(name, optimizer, fun, bounds, value_limit = math.inf, 
-            plot_limit = math.inf, num_retries = 1024, 
-            workers = mp.cpu_count(), logger=logger(), 
-            stop_fitness = -math.inf, statistic_num = 5000, plot_name = None):
+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, logger = logger, 
-                  statistic_num = statistic_num, plot_name = plot_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)
-    filtered = np.array([imp for imp in impr if imp[1] < plot_limit])
-    if len(filtered) > 0: impr = filtered
+    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, fname, interp=True, label=r'$\chi$', 
-         xlabel = r'$f_1$', ylabel = r'$f_2$', zlabel = r'$f_3$', plot3d=False):
+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
@@ -139,6 +150,11 @@ def plot(front, fname, interp=True, label=r'$\chi$',
             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]
@@ -152,16 +168,17 @@ def plot(front, fname, interp=True, label=r'$\chi$',
         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=1)
+    ax.scatter(x, y, label=label, s=s)
     ax.grid()
     ax.set_xlabel(xlabel)
     ax.set_ylabel(ylabel)
     ax.legend()
-    fig.savefig(fname, dpi=300)
+    fig.savefig(fname, dpi=dpi)
     pl.close('all')
 
-def plot3(front, fname, label=r'$\chi$', 
-         xlabel = r'$f_1$', ylabel = r'$f_2$', zlabel = r'$f_3$'):
+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')
@@ -175,22 +192,44 @@ def plot3(front, fname, label=r'$\chi$',
     #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, 
-                 fun, # fitness function
-                 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
-                 statistic_num = 0,
-                 plot_name = None # requires statistic_num > 500
+                 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)
@@ -200,31 +239,30 @@ 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)
         self.statistic_num = statistic_num
-        self.plot_name = plot_name
-        # statistics                            
+        # statistics   
+        self.statistic_num = statistic_num                         
         if statistic_num > 0:  # enable statistics                          
-            self.statistic_num = statistic_num
             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, math.inf)
+            self.bval = mp.RawValue(ct.c_double, np.inf)
 
     # register improvement - time and value
-    def wrapper(self, x):
+    def wrapper(self, x: ArrayLike):
         y = self.fun(x)
         self.sevals.value += 1
         if y < self.bval.value:
@@ -234,18 +272,18 @@ class Store(object):
                 self.si.value = si + 1
             self.time[si] = dtime(self.t0)
             self.val[si] = y  
-            if not self.logger is None:
-                self.logger.info(str(self.time[si]) + ' '  + 
-                          str(self.sevals.value) + ' ' + 
-                          str(y) + ' ' + 
-                          str(list(x)))
+            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 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]
         ys = self.val[:self.si.value]
         mt = ts[-1]
@@ -260,88 +298,83 @@ class Store(object):
             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.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):
+    def get_x_best(self) -> np.ndarray:
         return np.array(self.best_x[:])
     
-    def get_xs(self):
-        return np.array([self.get_x(i) for i in range(self.num_stored.value)])
-    
-    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):
+    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):
+    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
@@ -356,43 +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, store, optimize, num_retries, value_limit, stop_fitness = -math.inf):
-    fun = store.wrapper if store.statistic_num > 0 else store.fun
-    #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) 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)   
-            if not store.plot_name is None: 
-                name = store.plot_name + "_retry_" + str(store.get_count_evals())
-                xs = np.array(store.get_xs())
-                ys = np.array(store.get_ys())
-                np.savez_compressed(name, xs=xs, ys=ys) 
-                plot(y, name, interp=False)    
-        except Exception as ex:
-            print(str(ex))
-#        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:

fcmaes/test_cma.py

@@ -3,12 +3,12 @@
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory.
 
-import sys
 import multiprocessing as mp
 import numpy as np
 from scipy.optimize import OptimizeResult
 from fcmaes.testfun import Wrapper, Rosen, Rastrigin, Eggholder
-from fcmaes import cmaes, de, decpp, cmaescpp, gcldecpp, retry, advretry
+from fcmaes import cmaes, de, decpp, cmaescpp, retry, advretry
+from fcmaes.optimizer import de_cma_py
 
 def almost_equal(X1, X2, eps = 1E-5):
     if np.isscalar(X1):
@@ -168,27 +168,6 @@ def test_rosen_cpp_parallel():
     assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
     assert(almost_equal(ret.fun, wrapper.get_best_y(), eps = 1E-1)) # wrong best y returned
 
-def test_rosen_gclde_parallel():
-    popsize = 8
-    dim = 2
-    testfun = Rosen(dim)
-    max_eval = 10000    
-    limit = 0.00001   
-    for _ in range(5):
-        wrapper = Wrapper(testfun.fun, dim)
-        ret = gcldecpp.minimize(wrapper.eval, dim, testfun.bounds,
-                       max_evaluations = max_eval, 
-                       popsize=popsize, workers = mp.cpu_count())
-        if limit > ret.fun:
-            break
-       
-    assert(limit > ret.fun) # optimization target not reached
-    assert(max_eval + popsize >= ret.nfev) # too much function calls
-    assert(max_eval // popsize + 2 > ret.nit) # too much iterations
-    assert(ret.nfev == wrapper.get_count()) # wrong number of function calls returned
-    assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
-    assert(ret.fun == wrapper.get_best_y()) # wrong best y returned
-
 def test_rosen_de():
     popsize = 8
     dim = 2
@@ -339,15 +318,54 @@ def test_eggholder_retry():
     assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
     assert(ret.fun == wrapper.get_best_y()) # wrong best y returned
 
+from fcmaes.optimizer import de_cma
+
 def test_eggholder_advanced_retry():
     dim = 2
     testfun = Eggholder()
+    
+    limit = -956   
+    for _ in range(5):
+        wrapper = Wrapper(testfun.fun, dim)
+        ret = advretry.minimize(wrapper.eval, testfun.bounds, 
+                                num_retries=96)
+        if limit > ret.fun:
+            break
+        
+    assert(limit > ret.fun) # optimization target not reached
+    assert(ret.nfev == wrapper.get_count()) # wrong number of function calls returned
+    assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
+    assert(almost_equal(ret.fun, wrapper.get_best_y())) # wrong best y returned
+
+def test_eggholder_retry_python():
+    dim = 2
+    testfun = Eggholder()
+    
+    optimizer = de_cma_py(10000)
+    limit = -956   
+    for _ in range(5):
+        wrapper = Wrapper(testfun.fun, dim)
 
+        ret = retry.minimize(wrapper.eval, testfun.bounds, 
+                             num_retries=32, optimizer = optimizer)
+        if limit > ret.fun:
+            break
+
+    assert(limit > ret.fun) # optimization target not reached
+    assert(ret.nfev == wrapper.get_count()) # wrong number of function calls returned
+    assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
+    assert(ret.fun == wrapper.get_best_y()) # wrong best y returned
+
+def test_eggholder_advanced_retry_python():
+    dim = 2
+    testfun = Eggholder()
+
+    optimizer = de_cma_py(10000)
     limit = -956   
     for _ in range(5):
         wrapper = Wrapper(testfun.fun, dim)
         ret = advretry.minimize(wrapper.eval, testfun.bounds, 
-                                num_retries=300)
+                                num_retries=32, optimizer = optimizer)
         if limit > ret.fun:
             break
 
@@ -355,4 +373,6 @@ def test_eggholder_advanced_retry():
     assert(ret.nfev == wrapper.get_count()) # wrong number of function calls returned
     assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
     assert(almost_equal(ret.fun, wrapper.get_best_y())) # wrong best y returned
- 
+
+#test_rosen_decpp_parallel()
+ 

fcmaes-1.6.9.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.1
+Name: fcmaes
+Version: 1.6.9
+Summary: A Python 3 gradient-free optimization library.
+Home-page: https://github.com/dietmarwo/fast-cma-es
+Author: Dietmar Wolz
+Author-email: drdietmarwolz@yahoo.de
+License: MIT
+Keywords: optimization,multi-objective,parallel
+Classifier: Intended Audience :: Manufacturing
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Healthcare Industry
+Classifier: Intended Audience :: Telecommunications Industry
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Topic :: Office/Business :: Scheduling
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: scikit-learn
+Requires-Dist: threadpoolctl
+Requires-Dist: numba
+Requires-Dist: loguru
+
+# fcmaes
+A Python 3 gradient-free optimization library.
+
+- [README](https://github.com/dietmarwo/fast-cma-es/blob/master/README.adoc)
+- [Tutorials](https://github.com/dietmarwo/fast-cma-es/blob/master/tutorials/Tutorials.adoc)
+
+
+
+
+