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

fcmaes/moretry.py

@@ -0,0 +1,270 @@
+# Copyright (c) Dietmar Wolz.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory.
+
+# parallel optimization retry of a multi-objective problem.
+
+import numpy as np
+import math, sys, time, warnings, threadpoolctl
+import multiprocessing as mp
+from multiprocessing import Process
+from scipy.optimize import Bounds
+from numpy.random import Generator, PCG64DXSM, SeedSequence
+from fcmaes.optimizer import de_cma, dtime, Optimizer
+from fcmaes import retry, advretry
+from loguru import logger
+
+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.
+     
+    Parameters
+    ----------
+    fun : callable
+        The objective function to be minimized.
+            ``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.
+            2. Sequence of ``(min, max)`` pairs for each element in `x`. None
+               is used to specify no bound.
+    weight_bounds : `Bounds`, optional
+        Bounds on objective weights.
+    ncon : int, optional
+        number of constraints
+    value_exp : float, optional
+        exponent applied to the objective values for the weighted sum. 
+    value_limits : sequence of floats, optional
+        Upper limit for optimized objective values to be stored. 
+    num_retries : int, optional
+        Number of optimization retries.    
+    workers : int, optional
+        number of parallel processes used. Default is mp.cpu_count()
+    popsize = int, optional
+        CMA-ES population size used for all CMA-ES runs. 
+        Not used for differential evolution. 
+        Ignored if parameter optimizer is defined. 
+    max_evaluations : int, optional
+        Forced termination of all optimization runs after ``max_evaluations`` 
+        function evaluations. Only used if optimizer is undefined, otherwise
+        this setting is defined in the optimizer. 
+    capacity : int, optional
+        capacity of the evaluation store.
+    optimizer : optimizer.Optimizer, optional
+        optimizer to use. Default is a sequence of differential evolution and CMA-ES.
+    plot_name : plot_name, optional
+        if defined the pareto front is plotted during the optimization to monitor progress
+     
+    Returns
+    -------
+    xs, ys: list of argument vectors and corresponding value vectors of the optimization results. """
+
+    if optimizer is None:
+        optimizer = de_cma(max_evaluations, popsize)  
+    if capacity is None: 
+        capacity = num_retries
+    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: 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(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)]
+    [p.start() for p in proc]
+    [p.join() for p in proc]
+    store.sort()
+    store.dump()
+    return store.xs_view
+
+def _retry_loop(pid, rgs, fun, weight_bounds, ncon, y_exp, 
+                store, optimize, num_retries, value_limits):
+    
+    store.create_xs_view()
+    lower = store.lower
+    wlb = np.array(weight_bounds.lb)
+    wub = np.array(weight_bounds.ub)
+    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: np.ndarray, ys: np.ndarray):
+    """pareto front for argument vectors and corresponding function value vectors."""
+    par = _pareto(ys)
+    xp = xs[par]
+    yp = ys[par]
+    ya = np.argsort(yp.T[0])
+    return xp[ya], yp[ya]
+     
+class mo_wrapper(object):
+    """wrapper for multi objective functions applying the weighted sum approach."""
+   
+    def __init__(self, fun, weights, ncon, y_exp=2):
+        self.fun = fun  
+        self.weights = weights 
+        self.ny = len(weights)
+        self.nobj = self.ny - ncon
+        self.ncon = ncon
+        self.y_exp = y_exp
+
+    def eval(self, x):
+        y = self.fun(np.array(x))
+        weighted = _avg_exp(self.weights*y, self.y_exp)
+        if self.ncon > 0: # check constraint violations
+            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
+            
+    def mo_eval(self, x):
+        return self.fun(np.array(x))
+        
+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) 
+    xs, ys = minimize(fun, bounds, weight_bounds, ncon,
+             value_exp = exp,
+             value_limits = value_limits,
+             num_retries = num_retries,              
+             optimizer = optimizer,
+             workers = workers,
+             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, 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.fromiter((i for i in range(len(ys)) if con[i] < eps), dtype=int)
+            if len(feasible) > 0:
+                xs, ys = xs[feasible], np.array([y[:nobj] for y in ys[feasible]])
+            else:
+                print("no feasible")
+                return
+        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: 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,
+                           num_retries=num_retries, statistic_num = statistic_num) 
+    advretry.retry(store, optimizer.minimize, value_limit)
+    xs = np.array(store.get_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)
+    logger.info(name+ ' time ' + str(dtime(time0))) 
+    retry.plot(front, '_front_' + name + '.png')
+
+def _avg_exp(y, y_exp):
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        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
+    while index < len(ys):
+        mask = np.any(ys < ys[index], axis=1)
+        mask[index] = True
+        pareto = pareto[mask]  # Remove dominated points
+        ys = ys[mask]
+        index = np.sum(mask[:index])+1
+    return pareto
+    

fcmaes/multiretry.py

@@ -0,0 +1,195 @@
+# Copyright (c) Dietmar Wolz.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory.
+
+# parallel optimization retry of a list of problems. 
+
+import numpy as np
+import _pickle as cPickle
+import bz2
+import multiprocessing as mp
+from scipy.optimize import OptimizeResult, Bounds
+from fcmaes.optimizer import de_cma, eprint, Optimizer
+from fcmaes import advretry
+
+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. 
+    Can replace mixed integer optimization if the integer variables are narrowly bound. 
+    In this case all combinations of these integer values can be enumerated to generate a
+    list of problem instances each representing one combination. See for instance 
+    https://www.esa.int/gsp/ACT/projects/gtop/tandem where there is a problem instance for each
+    planet sequence.
+     
+    Parameters
+    ----------
+    
+    problems: list
+        list of objects providing name, fun and bounds attributes like fcmaes.astro.Astrofun
+
+    ids:  list, optional
+        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.
+
+    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. 
+                        
+    optimizer: optimizer.Optimizer, optional
+        optimizer to use for the problem filter.
+        
+    datafile, optional
+        file to persist / retrieve the internal state of the optimizations. 
+     
+    Returns
+    -------
+    dictionary( optimizer -> ret): scipy.OptimizeResult
+        The optimization result is represented as an ``OptimizeResult`` object.
+        Important attributes are: ``x`` the solution array, 
+        ``fun`` the best function value, ``nfev`` the number of function evaluations,
+        ``success`` a Boolean flag indicating if the optimizer exited successfully. """
+
+    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, retries_inc, num_retries))
+    
+    if not datafile is None:
+        solver.load(datafile)
+        
+    while solver.size() > 1:    
+        solver.retry(optimizer)
+        to_remove = int(round((1.0 - keep) * solver.size()))
+        if to_remove == 0 and keep < 1.0:
+            to_remove = 1
+        solver.remove_worst(to_remove)
+        solver.dump()
+        if not datafile is None:
+            solver.save(datafile)
+            
+    idx = solver.values_all().argsort()
+    return list(np.asarray(solver.all_stats)[idx])
+        
+class problem_stats:
+
+    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.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.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):
+        self.problem_stats = []
+        self.all_stats = []
+    
+    def add(self, stats):
+        self.problem_stats.append(stats)
+        self.all_stats.append(stats)
+    
+    def retry(self, optimizer):
+        for ps in self.problem_stats:
+            if is_debug_active():
+                logger.debug("problem " + ps.prob.name + ' ' + str(ps.id))
+            ps.retry(optimizer)
+    
+    def values(self):
+        return np.fromiter((ps.value for ps in self.problem_stats), dtype=float)
+     
+    def remove_worst(self, n = 1):
+        idx = self.values().argsort()
+        self.problem_stats = list(np.asarray(self.problem_stats)[idx])
+        for _ in range(n):
+            self.problem_stats.pop(-1)
+
+    def size(self):
+        return len(self.problem_stats)
+                    
+    def dump(self):
+        if is_debug_active():
+            for i in range(self.size()):
+                ps = self.problem_stats[i]
+                logger.debug(str(ps.id) + ' ' + str(ps.value))
+                
+    def dump_all(self):
+        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]
+                logger.debug(str(ps.id) + ' ' + str(ps.value))
+
+    def values_all(self):
+        return np.fromiter((ps.value for ps in self.all_stats), dtype=float)
+ 
+    def result(self):
+        idx = self.values_all().argsort()
+        self.all_stats = list(np.asarray(self.all_stats)[idx])
+        ret = []
+        for i in range(len(self.all_stats)):
+            problem = self.all_stats[i].prob
+            store = self.all_stats[i].store
+            ret.append([problem, 
+                        OptimizeResult(x=store.get_x_best(), fun=store.get_y_best(), 
+                          nfev=store.get_count_evals(), success=True)])
+            
+    # persist all stats
+    def save(self, name):
+        try:
+            with bz2.BZ2File(name + '.pbz2', 'w') as f: 
+                cPickle.dump(self.get_data(), f)
+        except Exception as ex:
+            eprint('error writing data file ' + name + '.pbz2 ' + str(ex))
+
+    def load(self, name):
+        try:
+            data = cPickle.load(bz2.BZ2File(name + '.pbz2', 'rb'))
+            self.set_data(data)
+        except Exception as ex:
+            eprint('error reading data file ' + name + '.pbz2 ' + str(ex))
+  
+    def get_data(self):
+        data = []
+        for stats in self.all_stats:            
+            data.append(stats.store.get_data())
+        return data
+        
+    def set_data(self, data):
+        for i in range(len(data)):
+            self.all_stats[i].store.set_data(data[i])
+        
+