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

fcmaes/moretry.py

@@ -6,30 +6,33 @@
 # parallel optimization retry of a multi-objective problem.
 
 import numpy as np
-import math, sys, time, warnings
+import math, sys, time, warnings, threadpoolctl
 import multiprocessing as mp
 from multiprocessing import Process
 from scipy.optimize import Bounds
-from numpy.random import Generator, MT19937, SeedSequence
-from fcmaes.optimizer import de_cma, logger, dtime
+from numpy.random import Generator, PCG64DXSM, SeedSequence
+from fcmaes.optimizer import de_cma, dtime, Optimizer
 from fcmaes import retry, advretry
+from loguru import logger
 
-def minimize(fun,             
-             bounds,
-             weight_bounds,
-             ncon = 0,
-             value_exp = 2.0,
-             value_limits = None,
-             num_retries = 1024,
-             logger = None,
-             workers = mp.cpu_count(),
-             popsize = 31, 
-             max_evaluations = 50000, 
-             capacity = None,
-             optimizer = None,
-             statistic_num = 0,
-             plot_name = None
-              ):   
+from typing import Optional, Callable, Tuple
+from numpy.typing import ArrayLike
+
+def minimize(fun: Callable[[ArrayLike], float],
+             bounds: Bounds,
+             weight_bounds: Bounds,
+             ncon: Optional[int] = 0,
+             value_exp: Optional[float] = 2.0,
+             value_limits: Optional[ArrayLike] = None,
+             num_retries: Optional[int] = 1024,
+             workers: Optional[int] = mp.cpu_count(),
+             popsize: Optional[int] = 31, 
+             max_evaluations: Optional[int] = 50000, 
+             capacity: Optional[int] = None,
+             optimizer: Optional[Optimizer] = None,
+             statistic_num: Optional[int] = 0,
+             plot_name: Optional[str] = None
+              ) -> Tuple[np.ndarray, np.ndarray]:   
     """Minimization of a multi objective function of one or more variables using parallel 
      optimization retry.
      
@@ -37,10 +40,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 objective 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
@@ -85,17 +82,26 @@ def minimize(fun,
         optimizer = de_cma(max_evaluations, popsize)  
     if capacity is None: 
         capacity = num_retries
-    store = retry.Store(fun, bounds, capacity = capacity, logger = logger, 
-                        statistic_num = statistic_num, plot_name = plot_name)
+    store = retry.Store(fun, bounds, capacity = capacity, 
+                        statistic_num = statistic_num)
+    store.plot_name = plot_name
     xs = np.array(mo_retry(fun, weight_bounds, ncon, value_exp, 
                            store, optimizer.minimize, num_retries, value_limits, workers))
     ys = np.array([fun(x) for x in xs])
     return xs, ys
     
-def mo_retry(fun, weight_bounds, ncon, y_exp, store, optimize, num_retries, value_limits, 
-          workers=mp.cpu_count()):
+def mo_retry(fun: Callable[[ArrayLike], float], 
+             weight_bounds: Bounds, 
+             ncon: int, 
+             y_exp: float, 
+             store, 
+             optimize: Callable, 
+             num_retries: int, 
+             value_limits: ArrayLike, 
+             workers: Optional[int] = mp.cpu_count()):
+    
     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, weight_bounds, ncon, y_exp, 
                   store, optimize, num_retries, value_limits)) for pid in range(workers)]
@@ -103,38 +109,38 @@ def mo_retry(fun, weight_bounds, ncon, y_exp, store, optimize, num_retries, valu
     [p.join() for p in proc]
     store.sort()
     store.dump()
-    return store.get_xs()
+    return store.xs_view
 
 def _retry_loop(pid, rgs, fun, weight_bounds, ncon, y_exp, 
                 store, optimize, num_retries, value_limits):
     
-    if 'win' in sys.platform and not store.logger is None:
-        store.logger = logger()       
+    store.create_xs_view()
     lower = store.lower
     wlb = np.array(weight_bounds.lb)
     wub = np.array(weight_bounds.ub)
-    while store.get_runs_compare_incr(num_retries):      
-        try:       
-            rg = rgs[pid]
-            w = rg.uniform(size=len(wub))          
-            w /= _avg_exp(w, y_exp) # correct scaling
-            w = wlb + w * (wub - wlb)
-            wrapper = mo_wrapper(fun, w, ncon, y_exp)  
-            x, y, evals = optimize(wrapper.eval, Bounds(store.lower, store.upper), None, 
-                                     [rg.uniform(0.05, 0.1)]*len(lower), rg, store)
-            objs = wrapper.mo_eval(x) # retrieve the objective values
-            if value_limits is None or all([objs[i] < value_limits[i] for i in range(len(w))]):
-                store.add_result(y, x, evals, math.inf)   
-                if not store.plot_name is None:
-                    name = store.plot_name + "_moretry_" + str(store.get_count_evals())
-                    xs = np.array(store.get_xs())
-                    ys = np.array([fun(x) for x in xs])
-                    np.savez_compressed(name, xs=xs, ys=ys) 
-                    plot(name, ncon, xs, ys)
-        except Exception as ex:
-            print(str(ex))
+    with threadpoolctl.threadpool_limits(limits=1, user_api="blas"):    
+        while store.get_runs_compare_incr(num_retries):      
+            try:       
+                rg = rgs[pid]
+                w = rg.uniform(size=len(wub))          
+                w /= _avg_exp(w, y_exp) # correct scaling
+                w = wlb + w * (wub - wlb)
+                wrapper = mo_wrapper(fun, w, ncon, y_exp)  
+                x, y, evals = optimize(wrapper.eval, Bounds(store.lower, store.upper), None, 
+                                         [rg.uniform(0.05, 0.1)]*len(lower), rg, store)
+                objs = wrapper.mo_eval(x) # retrieve the objective values
+                if value_limits is None or all([objs[i] < value_limits[i] for i in range(len(w))]):
+                    store.add_result(y, x, evals, np.inf)   
+                    if not store.plot_name is None:
+                        name = store.plot_name + "_moretry_" + str(store.get_count_evals())
+                        xs = np.array(store.get_xs())
+                        ys = np.array([fun(x) for x in xs])
+                        np.savez_compressed(name, xs=xs, ys=ys) 
+                        plot(name, ncon, xs, ys)
+            except Exception as ex:
+                print(str(ex))
             
-def pareto(xs, ys):
+def pareto(xs: np.ndarray, ys: np.ndarray):
     """pareto front for argument vectors and corresponding function value vectors."""
     par = _pareto(ys)
     xp = xs[par]
@@ -157,7 +163,7 @@ class mo_wrapper(object):
         y = self.fun(np.array(x))
         weighted = _avg_exp(self.weights*y, self.y_exp)
         if self.ncon > 0: # check constraint violations
-            violations = np.array([i for i in range(self.nobj, self.ny) if y[i] > 0])
+            violations = np.fromiter((i for i in range(self.nobj, self.ny) if y[i] > 0), dtype=int)
             if len(violations) > 0:
                 weighted += sum(self.weights[violations])     
         return weighted
@@ -165,10 +171,18 @@ class mo_wrapper(object):
     def mo_eval(self, x):
         return self.fun(np.array(x))
         
-def minimize_plot(name, optimizer, fun, bounds, weight_bounds, ncon = 0, 
-                  value_limits = None, num_retries = 1024, 
-             exp = 2.0, workers = mp.cpu_count(), 
-             logger=logger(), statistic_num = 0, plot_name = None):
+def minimize_plot(name: str, 
+                  optimizer: Optimizer, 
+                  fun: Callable[[ArrayLike], float], 
+                  bounds: Bounds, 
+                  weight_bounds, 
+                  ncon: Optional[int] = 0, 
+                  value_limits: Optional[ArrayLike] = None, 
+                  num_retries: Optional[int] = 1024, 
+                  exp: Optional[float] = 2.0, 
+                  workers: Optional[int] = mp.cpu_count(),
+                  statistic_num = 0, plot_name = None):
+    
     time0 = time.perf_counter() # optimization start time
     name += '_' + optimizer.name
     logger.info('optimize ' + name) 
@@ -178,43 +192,48 @@ def minimize_plot(name, optimizer, fun, bounds, weight_bounds, ncon = 0,
              num_retries = num_retries,              
              optimizer = optimizer,
              workers = workers,
-             logger=logger, statistic_num = statistic_num, plot_name = plot_name)
+             statistic_num = statistic_num, plot_name = plot_name)
     logger.info(name + ' time ' + str(dtime(time0))) 
     np.savez_compressed(name, xs=xs, ys=ys) 
     plot(name, ncon, xs, ys)
     
-def plot(name, ncon, xs, ys, eps = 1E-2):   
+def plot(name, ncon, xs, ys, eps = 1E-2, all=True, interp=False, plot3d=False):   
     try:  
         if ncon > 0: # select feasible
             ycon = np.array([np.maximum(y[-ncon:], 0) for y in ys])  
             con = np.sum(ycon, axis=1)
             nobj = len(ys[0]) - ncon
-            feasible = np.array([i for i in range(len(ys)) if con[i] < eps])
+            feasible = np.fromiter((i for i in range(len(ys)) if con[i] < eps), dtype=int)
             if len(feasible) > 0:
-                #yc = [y[nobj:] for y in ys[feasible]]
-                xs, ys = xs[feasible], np.array([ y[:nobj] for y in ys[feasible]])
+                xs, ys = xs[feasible], np.array([y[:nobj] for y in ys[feasible]])
             else:
+                print("no feasible")
                 return
-        retry.plot(ys, 'all_' + name + '.png', interp=False)
-        xs, front = pareto(xs, ys)
-        retry.plot(front, 'front_' + name + '.png', interp=False)
-        if ncon > 0:
-            for x, y, feas, in zip(xs, front, con[feasible]):
-                print(str(list(y)) + ' ' +  #str(feas) + ' ' + 
-                    str([int(xi) for xi in x]))
+        if all:
+            retry.plot(ys, 'all_' + name + '.png', interp=False)
+        xs, ys = pareto(xs, ys)
+        for x, y in zip(xs, ys):
+            print(str(list(y)) + ' ' + str([round(xi,5) for xi in x]))
+        retry.plot(ys, 'front_' + name + '.png', interp=interp, plot3d=plot3d)
     except Exception as ex:
         print(str(ex))
 
-def adv_minimize_plot(name, optimizer, fun, bounds,
-                   value_limit = math.inf, num_retries = 1024, logger=logger(), statistic_num = 0):
+def adv_minimize_plot(name: str, 
+                      optimizer: Optimizer, 
+                      fun: Callable[[ArrayLike], float], 
+                      bounds: Optional[Bounds],
+                      value_limit: Optional[float] = np.inf, 
+                      num_retries: Optional[int] = 1024, 
+                      statistic_num: Optional[int] = 0):
+    
     time0 = time.perf_counter() # optimization start time
     name += '_smart_' + optimizer.name
     logger.info('smart optimize ' + name) 
-    store = advretry.Store(lambda x:fun(x)[0], bounds, capacity=5000, logger=logger, 
+    store = advretry.Store(lambda x:fun(x)[0], bounds, capacity=5000,
                            num_retries=num_retries, statistic_num = statistic_num) 
     advretry.retry(store, optimizer.minimize, value_limit)
     xs = np.array(store.get_xs())
-    ys = np.array([fun(x) for x in xs])
+    ys = np.fromiter((fun(x) for x in xs), dtype=float)
     retry.plot(ys, '_all_' + name + '.png', interp=False)
     np.savez_compressed(name , xs=xs, ys=ys)
     xs, front = pareto(xs, ys)
@@ -227,6 +246,17 @@ def _avg_exp(y, y_exp):
         weighted = sum([y[i]**y_exp for i in range(len(y))])**(1.0/y_exp)
     return weighted
 
+def _pareto_values(ys):
+    ys = ys[ys.sum(1).argsort()[::-1]]
+    undominated = np.ones(ys.shape[0], dtype=bool)
+    for i in range(ys.shape[0]):
+        n = ys.shape[0]
+        if i >= n:
+            break
+        undominated[i+1:n] = (ys[i+1:] >= ys[i]).any(1) 
+        ys = ys[undominated[:n]]
+    return ys
+
 def _pareto(ys):
     pareto = np.arange(ys.shape[0])
     index = 0  # Next index to search for

fcmaes/multiretry.py

@@ -9,12 +9,22 @@ import numpy as np
 import _pickle as cPickle
 import bz2
 import multiprocessing as mp
-from scipy.optimize import OptimizeResult
-from fcmaes.optimizer import logger, de_cma, eprint
+from scipy.optimize import OptimizeResult, Bounds
+from fcmaes.optimizer import de_cma, eprint, Optimizer
 from fcmaes import advretry
 
-def minimize(problems, ids=None, num_retries = min(256, 8*mp.cpu_count()), 
-             keep = 0.7, optimizer = de_cma(1500), logger = None, datafile = None):
+from fcmaes.evaluator import is_debug_active
+from loguru import logger
+from typing import Optional, Callable, Tuple, List
+from numpy.typing import ArrayLike
+
+def minimize(problems: ArrayLike, 
+             ids: Optional[ArrayLike] = None, 
+             retries_inc: Optional[int] = min(256, 8*mp.cpu_count()), 
+             num_retries: Optional[int] = 10000,
+             keep: Optional[float] = 0.7, 
+             optimizer: Optional[Optimizer] = de_cma(1500), 
+             datafile = None) -> List:
       
     """Minimization of a list of optimization problems by first applying parallel retry
     to filter the best ones and then applying coordinated retry to evaluate these further. 
@@ -34,10 +44,13 @@ def minimize(problems, ids=None, num_retries = min(256, 8*mp.cpu_count()),
         list of objects corresponding to the list of problems used in logging to identify the 
         problem variant currently logged. If None, the index of the problem 
         variant is used instead.
-    
-    num_retries:  int, optional
+
+    retries_inc:  int, optional
         number of coordinated retries applied in the problem filter for each problem 
         in each iteration.
+    
+    num_retries:  int, optional
+        number of coordinated retries applied in the problem filter for the winner problem.
  
     keep:  float, optional
         rate of the problems kept after each iteration. 100*(1 - keep) % will be deleted. 
@@ -45,11 +58,6 @@ def minimize(problems, ids=None, num_retries = min(256, 8*mp.cpu_count()),
     optimizer: optimizer.Optimizer, optional
         optimizer to use for the problem filter.
         
-    logger, optional
-        logger for log output. If None, logging
-        is switched off. Default is a logger which logs both to stdout and
-        appends to a file.  
-        
     datafile, optional
         file to persist / retrieve the internal state of the optimizations. 
      
@@ -61,12 +69,12 @@ def minimize(problems, ids=None, num_retries = min(256, 8*mp.cpu_count()),
         ``fun`` the best function value, ``nfev`` the number of function evaluations,
         ``success`` a Boolean flag indicating if the optimizer exited successfully. """
 
-    solver = multiretry(logger)
+    solver = multiretry()
     n = len(problems)
         
     for i in range(n):    
         id = str(i+1) if ids is None else ids[i]   
-        solver.add(problem_stats(problems[i], id, i, num_retries, logger))
+        solver.add(problem_stats(problems[i], id, i, retries_inc, num_retries))
     
     if not datafile is None:
         solver.load(datafile)
@@ -86,29 +94,28 @@ def minimize(problems, ids=None, num_retries = min(256, 8*mp.cpu_count()),
         
 class problem_stats:
 
-    def __init__(self, prob, id, index, num_retries = 64, logger = None):
-        self.store = advretry.Store(prob.bounds, logger = logger, num_retries=num_retries)
+    def __init__(self, prob, id, index, retries_inc = 64, num_retries = 10000):
+        self.store = advretry.Store(prob.fun, prob.bounds, num_retries=num_retries)
         self.prob = prob
         self.name = prob.name
         self.fun = prob.fun
-        self.num_retries = num_retries
-        self.retries = 0
+        self.retries_inc = retries_inc
         self.value = 0
         self.id = id
         self.index = index
         self.ret = None
+        self.store.num_retries = self.retries_inc
 
     def retry(self, optimizer):
-        self.retries += self.num_retries
-        self.ret = advretry.retry(self.fun, self.store, optimizer.minimize)
+        self.store.num_retries += self.retries_inc
+        self.ret = advretry.retry(self.store, optimizer.minimize)
         self.value = self.store.get_y_best()
  
 class multiretry:
     
-    def __init__(self, logger = None):
+    def __init__(self):
         self.problem_stats = []
         self.all_stats = []
-        self.logger = logger
     
     def add(self, stats):
         self.problem_stats.append(stats)
@@ -116,12 +123,12 @@ class multiretry:
     
     def retry(self, optimizer):
         for ps in self.problem_stats:
-            if not self.logger is None:
-                self.logger.info("problem " + ps.prob.name + ' ' + str(ps.id))
+            if is_debug_active():
+                logger.debug("problem " + ps.prob.name + ' ' + str(ps.id))
             ps.retry(optimizer)
     
     def values(self):
-        return np.array([ps.value for ps in self.problem_stats])
+        return np.fromiter((ps.value for ps in self.problem_stats), dtype=float)
      
     def remove_worst(self, n = 1):
         idx = self.values().argsort()
@@ -133,21 +140,21 @@ class multiretry:
         return len(self.problem_stats)
                     
     def dump(self):
-        if not self.logger is None:
+        if is_debug_active():
             for i in range(self.size()):
                 ps = self.problem_stats[i]
-                self.logger.info(str(ps.id) + ' ' + str(ps.value))
+                logger.debug(str(ps.id) + ' ' + str(ps.value))
                 
     def dump_all(self):
-        if not self.logger is None:
+        if is_debug_active():
             idx = self.values_all().argsort()
             self.all_stats = list(np.asarray(self.all_stats)[idx])
             for i in range(len(self.all_stats)):
                 ps = self.all_stats[i]
-                self.logger.info(str(ps.id) + ' ' + str(ps.value))
+                logger.debug(str(ps.id) + ' ' + str(ps.value))
 
     def values_all(self):
-        return np.array([ps.value for ps in self.all_stats])
+        return np.fromiter((ps.value for ps in self.all_stats), dtype=float)
  
     def result(self):
         idx = self.values_all().argsort()
@@ -185,4 +192,4 @@ class multiretry:
         for i in range(len(data)):
             self.all_stats[i].store.set_data(data[i])
         
-    
+