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

fcmaes/diversifier.py

@@ -0,0 +1,357 @@
+# Copyright (c) Dietmar Wolz.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory.
+from __future__ import annotations
+
+""" Numpy based implementation of an diversifying wrapper / parallel retry mechanism. 
+
+Uses the archive from CVT MAP-Elites (https://arxiv.org/abs/1610.05729)
+and generalizes ideas from CMA-ME (https://arxiv.org/pdf/1912.02400.pdf)
+to other wrapped algorithms. 
+
+Both the parallel retry and the archive based modification of the fitness 
+function enhance the diversification of the optimization result.
+The resulting archive may be stored and can be used to continue the
+optimization later.   
+
+Requires a QD-fitness function returning both an fitness value and a
+behavior vector used to determine the corresponding archive niche using
+Voronoi tesselation. 
+
+Returns an archive of niche-elites containing also for each niche statistics 
+about the associated solutions.     
+"""
+
+import numpy as np
+from numpy.random import Generator, PCG64DXSM, SeedSequence
+from multiprocessing import Process
+from scipy.optimize import Bounds
+from fcmaes.optimizer import dtime, de_cma, Optimizer
+import multiprocessing as mp
+import ctypes as ct
+from time import perf_counter
+from fcmaes.mapelites import Archive, update_archive, rng
+from fcmaes import advretry
+from fcmaes.evaluator import is_debug_active
+from loguru import logger
+import threadpoolctl
+
+from typing import Optional, Callable, Tuple, Dict
+from numpy.typing import ArrayLike
+
+def minimize(qd_fitness: Callable[[ArrayLike], Tuple[float, np.ndarray]], 
+            bounds: Bounds,
+            qd_bounds: Bounds,
+            niche_num: Optional[int] = 10000,
+            samples_per_niche: Optional[int] = 20,
+            max_evals: Optional[int] = None,
+            workers: Optional[int] = mp.cpu_count(),
+            archive: Optional[Archive] = None,
+            opt_params: Optional[Dict] = {},
+            use_stats: Optional[bool] = False,            
+            ) -> Archive:
+    
+    """Wraps an fcmaes optmizer/solver by hijacking its tell function.
+    Works as CVT Map-Elites in maintaining an archive of diverse elites. 
+    But this archive is not used to derive solution vectors, but to reevaluate them. 
+    For each fitness result it determines its niche. The "told" fitness is
+    determined relative to its local elite. If it is better the evaluated solution
+    becomes the new niche-elite.  
+    This way the wrapped solver is "tricked" to follow a QD-goal: Finding empty niches
+    and improving all niches. This works not only for CMA-ES, but also for other 
+    solvers: DE, CR-FM-NES and PGPE. Both their Python and C++ versions are supported. 
+     
+    Parameters
+    ----------
+    solver : evolutionary algorithm, needs to support ask/tell 
+    qd_fitness : callable
+        The objective function to be minimized. Returns a fitness value and a behavior vector. 
+            ``qd_fitness(x) -> float, array``
+        where ``x`` is an 1-D array with shape (n,)
+    bounds : `Bounds`
+        Bounds on variables. Instance of the `scipy.Bounds` class.
+    qd_bounds : `Bounds`
+        Bounds on behavior descriptors. Instance of the `scipy.Bounds` class.        
+    niche_num : int, optional
+        Number of niches.
+    samples_per_niche : int, optional
+        Number of samples used for niche computation. 
+        If samples_per_niche > 0 cvt-clustering is used, else grid-clustering is used. 
+    max_evals : int, optional
+        Number of fitness evaluations.
+    workers : int, optional
+        Number of spawned parallel worker processes.
+    archive : Archive, optional
+        If defined MAP-elites is continued for this archive.
+    opt_params : dictionary, optional (or a list/tuple/array of these)
+        Parameters selecting and configuring the wrapped solver.
+        'solver' - supported are 'CMA','CMA_CPP','CRMFNES','CRMFNES_CPP','DE','DE_CPP','PGPE'
+                    default is 'CMA_CPP'
+        'popsize' - population size, default = 32
+        'sigma' -  initial distribution sigma, default = rg.uniform(0.03, 0.3)**2)
+        'mean' - initial distribution mean, default=rg.uniform(bounds.lb, bounds.ub)) 
+        'max_evals' - maximal number of evaluations per run, default = 50000
+        'stall_criterion' - how many iterations without progress allowed, default = 50 iterations 
+        If a list/tuple/array of parameters are given, the corresponding solvers are called in a 
+        sequence.      
+    use_stats : bool, optional 
+        If True, archive accumulates statistics of the solutions
+                
+    Returns
+    -------
+    archive : Archive
+        Resulting archive of niches. Can be stored for later continuation of MAP-elites."""
+
+    if max_evals is None:
+        max_evals = workers*50000
+    dim = len(bounds.lb)
+    if archive is None: 
+        archive = Archive(dim, qd_bounds, niche_num, use_stats)
+        archive.init_niches(samples_per_niche)
+        # initialize archive with random values
+        archive.xs_view[:] = rng.uniform(bounds.lb, bounds.ub, (niche_num, dim))       
+    t0 = perf_counter()   
+    qd_fitness.archive = archive # attach archive for logging     
+    minimize_parallel_(archive, qd_fitness, bounds, workers, opt_params, max_evals)
+    if is_debug_active():
+        ys = np.sort(archive.get_ys())[:min(100, archive.capacity)] # best fitness values
+        logger.debug(f'best {min(ys):.3f} worst {max(ys):.3f} ' + 
+                 f'mean {np.mean(ys):.3f} stdev {np.std(ys):.3f} time {dtime(t0)} s')
+    return archive
+
+def apply_advretry(fitness: Callable[[ArrayLike], float], 
+                   qd_fitness: Callable[[ArrayLike], Tuple[float, np.ndarray]], 
+                   bounds: Bounds, 
+                   archive: Archive, 
+                   optimizer: Optional[Optimizer] = None, 
+                   num_retries: Optional[int] = 1000, 
+                   workers: Optional[int] = mp.cpu_count(),
+                   max_eval_fac: Optional[float] = 5.0,
+                   xs: Optional[np.ndarray] = None,
+                   ys: Optional[np.ndarray] = None,
+                   x_conv: Callable[[ArrayLike], ArrayLike] = None):
+        
+    """Unifies the QD world with traditional optimization. It converts
+    a QD-archive into a multiprocessing store used by the fcmaes smart
+    boundary management meta algorithm (advretry). Then advretry is applied
+    to find the global optimum. Finally the updated store is feed back into
+    the QD-archive. For this we need a descriptor generating function 
+    'descriptors' which may require reevaluation of the new solutions.  
+        
+    Parameters
+    ----------
+    solver : evolutionary algorithm, needs to support ask/tell 
+    fitness : callable
+        The objective function to be minimized. Returns a fitness value. 
+            ``fitness(x) -> float``
+    qf_fun : callable
+        Generates the descriptors for a solution. Returns a behavior vector. 
+            ``descriptors(x) -> array``
+        where ``x`` is an 1-D array with shape (n,)
+    bounds : `Bounds`
+        Bounds on variables. Instance of the `scipy.Bounds` class.
+    archive : Archive
+        Improves the solutions if this archive.
+    optimizer : optimizer.Optimizer, optional
+        Optimizer to use. Default is a sequence of differential evolution and CMA-ES.
+    num_retries : int, optional
+        Number of optimization runs.
+    workers : int, optional
+        Number of spawned parallel worker processes.
+    max_eval_fac : int, optional
+        Final limit of the number of function evaluations = max_eval_fac*min_evaluations  
+    xs : ndarray, optional
+        Used to initialize advretry. If undefined the archive content is used. 
+        If xs is defined, ys must be too
+    ys : ndarray, optional
+        Used to initialize advretry. If undefined the archive content is used.  
+    x_conv : callable, optional
+        If defined converts the x in xs to solutions suitable for the given archive.
+        If undefined it is assumed that the x in xs are valid archive solutons.   
+    """
+
+    if optimizer is None:
+        optimizer = de_cma(1500)
+    # generate advretry store
+    store = advretry.Store(fitness, bounds, num_retries=num_retries, 
+                           max_eval_fac=max_eval_fac)  
+                         
+    # select only occupied entries
+    if xs is None:
+        ys = archive.get_ys()    
+        valid = (ys < np.inf)
+        ys = ys[valid]
+        xs = archive.xs_view[valid]
+    t0 = perf_counter() 
+    # transfer to advretry store
+    for i in range(len(ys)):
+        store.add_result(ys[i], xs[i], 1)
+    # perform parallel retry
+    advretry.retry(store, optimizer.minimize, workers=workers)
+    # transfer back to archive 
+    xs = store.xs_view
+    if not x_conv is None:
+        xs = [x_conv(x) for x in xs]
+    yds = [qd_fitness(x) for x in xs]
+    descs = np.array([yd[1] for yd in yds])
+    ys = np.array([yd[0] for yd in yds])
+    niches = archive.index_of_niches(descs)
+    for i in range(len(ys)):
+        archive.set(niches[i], (ys[i], descs[i]), xs[i])
+    archive.argsort()
+    if is_debug_active():
+        ys = np.sort(archive.get_ys())[:min(100, archive.capacity)] # best fitness values
+        logger.debug(f'best {min(ys):.3f} worst {max(ys):.3f} ' + 
+                 f'mean {np.mean(ys):.3f} stdev {np.std(ys):.3f} time {dtime(t0)} s')    
+
+def minimize_parallel_(archive, fitness, bounds, workers, opt_params, max_evals):
+    sg = SeedSequence()
+    rgs = [Generator(PCG64DXSM(s)) for s in sg.spawn(workers)]
+    evals = mp.RawValue(ct.c_long, 0)
+    proc=[Process(target=run_minimize_,
+            args=(archive, fitness, bounds, rgs[p],
+                  opt_params, p, workers, evals, max_evals)) for p in range(workers)]
+    [p.start() for p in proc]
+    [p.join() for p in proc]
+                    
+def run_minimize_(archive, fitness, bounds, rg, opt_params, p, workers, evals, max_evals):  
+    with threadpoolctl.threadpool_limits(limits=1, user_api="blas"):
+        if isinstance(opt_params, (list, tuple, np.ndarray)):
+            default_workers = int(workers/2) if len(opt_params) > 1 else workers
+            for params in opt_params: # call MAP-Elites
+                if 'elites' == params.get('solver'):
+                    elites_workers = params.get('workers', default_workers) 
+                    if p < elites_workers:
+                        run_map_elites_(archive, fitness, bounds, rg, evals, max_evals, params)
+                        return
+        while evals.value < max_evals: # call solvers in loop     
+            best_x = None
+            if isinstance(opt_params, (list, tuple, np.ndarray)):
+                for params in opt_params: # call in sequence
+                    if 'elites' == params.get('solver'):
+                        continue # ignore in loop
+                    if best_x is None:
+                        # selecting a niche elite is no improvement over random x0
+                        x0 = None#, _, _ = archive.random_xs_one(select_n, rg)
+                        best_x = minimize_(archive, fitness, bounds, rg, evals, max_evals, params, 
+                                           x0 = x0)
+                    else:
+                        best_x = minimize_(archive, fitness, bounds, rg, evals, max_evals, params, x0 = best_x)
+            else:        
+                minimize_(archive, fitness, bounds, rg, evals, max_evals, opt_params) 
+
+from fcmaes.mapelites import variation_,  iso_dd_
+                
+def run_map_elites_(archive, fitness, bounds, rg, evals, max_evals, opt_params = {}):    
+    popsize = opt_params.get('popsize', 32)  
+    use_sbx = opt_params.get('use_sbx', True)     
+    dis_c = opt_params.get('dis_c', 20)   
+    dis_m = opt_params.get('dis_m', 20)  
+    iso_sigma = opt_params.get('iso_sigma', 0.01)
+    line_sigma = opt_params.get('line_sigma', 0.2)
+    select_n = archive.capacity
+    while evals.value < max_evals:              
+        if use_sbx:
+            pop = archive.random_xs(select_n, popsize, rg)
+            xs = variation_(pop, bounds.lb, bounds.ub, rg, dis_c, dis_m)
+        else:
+            x1 = archive.random_xs(select_n, popsize, rg)
+            x2 = archive.random_xs(select_n, popsize, rg)
+            xs = iso_dd_(x1, x2, bounds.lb, bounds.ub, rg, iso_sigma, line_sigma)    
+        yds = [fitness(x) for x in xs]
+        evals.value += popsize
+        descs = np.array([yd[1] for yd in yds])
+        niches = archive.index_of_niches(descs)
+        for i in range(len(yds)):
+            archive.set(niches[i], yds[i], xs[i])
+        archive.argsort()   
+        select_n = archive.get_occupied()  
+
+def minimize_(archive, fitness, bounds, rg, evals, max_evals, opt_params, x0 = None): 
+    if 'BITE_CPP' == opt_params.get('solver'):
+        return run_bite_(archive, fitness, bounds, rg, evals, max_evals, opt_params, x0 = None)
+    else:
+        es = get_solver_(bounds, opt_params, rg, x0) 
+        stall_criterion = opt_params.get('stall_criterion', 20)
+        max_evals_iter = opt_params.get('max_evals', 50000)
+        max_iters = int(max_evals_iter/es.popsize)
+        old_ys = None
+        last_improve = 0
+        best_x = None
+        best_y = np.inf
+        for iter in range(max_iters):
+            xs = es.ask()
+            ys, real_ys = update_archive(archive, xs, fitness)
+            evals.value += es.popsize
+            # update best real fitness
+            yi = np.argmin(real_ys)
+            ybest = real_ys[yi] 
+            if ybest < best_y:
+                best_y = ybest
+                best_x = xs[yi]
+            if not old_ys is None:
+                if (np.sort(ys) < old_ys).any():
+                    last_improve = iter          
+            if last_improve + stall_criterion < iter:
+                break
+            stop = es.tell(ys)
+            if stop != 0 or evals.value >= max_evals:
+                break 
+            old_ys = np.sort(ys)
+        return best_x # real best solution
+
+from fcmaes import cmaes, cmaescpp, crfmnescpp, pgpecpp, decpp, crfmnes, de, bitecpp
+
+def run_bite_(archive, fitness, bounds, rg, evals, max_evals, opt_params, x0 = None):  
+    # BiteOpt doesn't support ask/tell, so we have to "patch" fitness. Note that Voronoi 
+    # tesselation is more expensive if called for single behavior vectors and not for batches. 
+    
+    def fit(x: Callable[[ArrayLike], float]):
+        if evals.value >= max_evals:
+            return np.inf
+        evals.value += 1
+        ys, _ = update_archive(archive, [x], fitness)
+        return ys[0]
+    
+    max_evals_iter = opt_params.get('max_evals', 50000)       
+    stall_criterion = opt_params.get('stall_criterion', 20)   
+    #popsize = opt_params.get('popsize', 0) 
+    ret = bitecpp.minimize(fit, bounds, x0 = x0, M = 1, 
+                           stall_criterion = stall_criterion,
+                           max_evaluations = max_evals_iter, rg = rg)
+    return ret.x   
+
+def get_solver_(bounds, opt_params, rg, x0 = None):
+    dim = len(bounds.lb)
+    popsize = opt_params.get('popsize', 31) 
+    #sigma = opt_params.get('sigma',rg.uniform(0.03, 0.3)**2)
+    sigma = opt_params.get('sigma',rg.uniform(0.1, 0.5)**2)
+    #sigma = opt_params.get('sigma',rg.uniform(0.2, 0.5)**2)
+    #sigma = opt_params.get('sigma',rg.uniform(0.1, 0.5))
+    mean = opt_params.get('mean', rg.uniform(bounds.lb, bounds.ub)) \
+                if x0 is None else x0
+    name = opt_params.get('solver', 'CMA_CPP')
+    if name == 'CMA':
+        return cmaes.Cmaes(bounds, x0 = mean,
+                          popsize = popsize, input_sigma = sigma, rg = rg)
+    elif name == 'CMA_CPP':
+        return cmaescpp.ACMA_C(dim, bounds, x0 = mean, #stop_hist = 0,
+                          popsize = popsize, input_sigma = sigma, rg = rg)
+    elif name == 'CRMFNES':
+        return crfmnes.CRFMNES(dim, bounds, x0 = mean,
+                          popsize = popsize, input_sigma = sigma, rg = rg)
+    elif name == 'CRMFNES_CPP':
+        return crfmnescpp.CRFMNES_C(dim, bounds, x0 = mean,
+                          popsize = popsize, input_sigma = sigma, rg = rg)
+    elif name == 'DE':
+        return de.DE(dim, bounds, popsize = popsize, rg = rg)
+    elif name == 'DE_CPP':
+        return decpp.DE_C(dim, bounds, popsize = popsize, rg = rg)
+    elif name == 'PGPE':
+        return pgpecpp.PGPE_C(dim, bounds, x0 = mean,
+                          popsize = popsize, input_sigma = sigma, rg = rg)
+    else:
+        print ("invalid solver")
+        return None
+            

fcmaes/evaluator.py

@@ -2,6 +2,7 @@
 #
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory.
+from __future__ import annotations
 
 """ Parallel objective function evaluator.
     Uses pipes to avoid re-spawning new processes for each eval_parallel call. 
@@ -12,14 +13,49 @@
 
 from multiprocessing import Process, Pipe
 import multiprocessing as mp
+import ctypes as ct
 import numpy as np
-import sys 
-import math   
+import sys, math, os  
+from loguru import logger
+from typing import Optional, Callable, Tuple
+from numpy.typing import ArrayLike
 
-def eval_parallel(xs, evaluator):
+pipe_limit = 64 # higher values can cause issues
+
+def is_log_level_active(level):
+    try: # nasty but currently there is no other way
+        for handler in logger._core.handlers.values():
+            if handler._levelno <= logger.level(level).no:
+                return True
+    except Exception as ex:   
+        pass
+    return False
+
+def is_debug_active():
+    return is_log_level_active("DEBUG")
+
+def is_trace_active():
+    return is_log_level_active("TRACE")
+
+def eval_parallel(xs: ArrayLike, 
+                  evaluator: Evaluator):
     popsize = len(xs)
     ys = np.empty(popsize)
-    pipe_limit = 256
+    i0 = 0
+    i1 = min(popsize, pipe_limit)
+    while True:
+        _eval_parallel_segment(xs, ys, i0, i1, evaluator)
+        if i1 >= popsize:
+            break;
+        i0 += pipe_limit
+        i1 = min(popsize, i1 + pipe_limit)
+    return ys
+        
+def eval_parallel_mo(xs: ArrayLike, 
+                     evaluator: Evaluator, 
+                     nobj: int):
+    popsize = len(xs)
+    ys = np.empty((popsize,nobj))
     i0 = 0
     i1 = min(popsize, pipe_limit)
     while True:
@@ -33,14 +69,14 @@ def eval_parallel(xs, evaluator):
 class Evaluator(object):
        
     def __init__(self, 
-                 fun, # objective function
+                 fun: Callable[[ArrayLike], float], # objective function
                 ):   
         self.fun = fun 
         self.pipe = Pipe()
         self.read_mutex = mp.Lock() 
         self.write_mutex = mp.Lock() 
             
-    def start(self, workers=mp.cpu_count()):
+    def start(self, workers: Optional[int] = mp.cpu_count()):
         self.workers = workers
         self.proc=[Process(target=_evaluate, args=(self.fun, 
                 self.pipe, self.read_mutex, self.write_mutex)) for _ in range(workers)]
@@ -74,3 +110,240 @@ def _evaluate(fun, pipe, read_mutex, write_mutex): # worker
             y =  sys.float_info.max
         with write_mutex:            
             pipe[1].send((i, y)) # Send result
+
+def _check_bounds(bounds, guess, rg):
+    if bounds is None and guess is None:
+        raise ValueError('either guess or bounds need to be defined')
+    if bounds is None:
+        return None, None, np.asarray(guess)
+    if guess is None:
+        guess = rg.uniform(bounds.lb, bounds.ub)
+    return np.asarray(bounds.lb), np.asarray(bounds.ub), np.asarray(guess)
+
+def _get_bounds(dim, bounds, guess, rg):
+    if bounds is None:
+        if guess is None:
+            guess = np.asarray(np.zeros(dim))
+        return None, None, guess
+    if guess is None:
+        guess = rg.uniform(bounds.lb, bounds.ub)
+    return np.asarray(bounds.lb), np.asarray(bounds.ub), np.asarray(guess)
+
+class _fitness(object):
+    """wrapper around the objective function, scales relative to boundaries."""
+     
+    def __init__(self, fun, lower, upper, normalize = None):
+        self.fun = fun
+        self.evaluation_counter = 0
+        self.lower = lower
+        self.normalize = False
+        if not (lower is None or normalize is None):
+            self.normalize = normalize
+        if not lower is None:
+            self.upper = upper
+            self.scale = 0.5 * (upper - lower)
+            self.typx = 0.5 * (upper + lower)
+
+    def values(self, Xs): #enables parallel evaluation
+        values = self.fun(Xs)
+        self.evaluation_counter += len(Xs)
+        return np.array(values)
+    
+    def closestFeasible(self, X):
+        if self.lower is None:
+            return X    
+        else:
+            if self.normalize:
+                return np.clip(X, -1.0, 1.0)
+            else:
+                return np.clip(X, self.lower, self.upper)
+
+    def encode(self, X):
+        if self.normalize:
+            return (X - self.typx) / self.scale
+        else:
+            return X
+   
+    def decode(self, X):
+        if self.normalize:
+            return (X * self.scale) + self.typx
+        else:
+            return X
+         
+def serial(fun):
+    """Convert an objective function for serial execution for cmaes.minimize.
+    
+    Parameters
+    ----------
+    fun : objective function mapping a list of float arguments to a float value
+
+    Returns
+    -------
+    out : function
+        A function mapping a list of lists of float arguments to a list of float values
+        by applying the input function in a loop."""
+  
+    return lambda xs : [_tryfun(fun, x) for x in xs]
+        
+def _func_serial(fun, num, pid, xs, ys):
+    for i in range(pid, len(xs), num):
+        ys[i] = _tryfun(fun, xs[i])
+
+def _tryfun(fun, x):
+    try:
+        fit = fun(x)
+        return fit if math.isfinite(fit) else sys.float_info.max
+    except Exception:
+        return sys.float_info.max
+    
+class parallel(object):
+    """Convert an objective function for parallel execution for cmaes.minimize.
+    
+    Parameters
+    ----------
+    fun : objective function mapping a list of float arguments to a float value.
+   
+    represents a function mapping a list of lists of float arguments to a list of float values
+    by applying the input function using parallel processes. stop needs to be called to avoid
+    a resource leak"""
+        
+    def __init__(self, 
+                 fun: Callable[[ArrayLike], float], 
+                 workers: Optional[int] = mp.cpu_count()):
+        self.evaluator = Evaluator(fun)
+        self.evaluator.start(workers)
+    
+    def __call__(self, xs: ArrayLike) -> np.ndarray:
+        return eval_parallel(xs, self.evaluator)
+
+    def stop(self):
+        self.evaluator.stop()
+
+class parallel_mo(object):
+        
+    def __init__(self, 
+                 fun: Callable[[ArrayLike], ArrayLike], 
+                 nobj: int, 
+                 workers: Optional[int] = mp.cpu_count()):
+        self.nobj = nobj
+        self.evaluator = Evaluator(fun)
+        self.evaluator.start(workers)
+    
+    def __call__(self, xs: ArrayLike) -> np.ndarray:
+        return eval_parallel_mo(xs, self.evaluator, self.nobj)
+
+    def stop(self):
+        self.evaluator.stop()
+
+class callback(object):
+    
+    def __init__(self, fun: Callable[[ArrayLike], float]):
+        self.fun = fun
+    
+    def __call__(self, n: int, x: ArrayLike) -> float:
+        try:
+            fit = self.fun(np.fromiter((x[i] for i in range(n)), dtype=float))
+            return fit if math.isfinite(fit) else sys.float_info.max
+        except Exception as ex:
+            return sys.float_info.max
+        
+class callback_so(object):
+    
+    def __init__(self, 
+                 fun: Callable[[ArrayLike], float], 
+                 dim: int, 
+                 is_terminate: Optional[Callable[[ArrayLike, float], bool]] = None):
+        self.fun = fun
+        self.dim = dim
+        self.nobj = 1
+        self.is_terminate = is_terminate
+    
+    def __call__(self, dim, x, y):
+        try:
+            arrTypeX = ct.c_double*(self.dim)
+            xaddr = ct.addressof(x.contents)
+            xbuf = np.frombuffer(arrTypeX.from_address(xaddr))
+            arrTypeY = ct.c_double*(self.nobj)
+            yaddr = ct.addressof(y.contents)   
+            ybuf = np.frombuffer(arrTypeY.from_address(yaddr))  
+            fit = self.fun(xbuf)
+            ybuf[0] = fit if math.isfinite(fit) else sys.float_info.max
+            return False if self.is_terminate is None else self.is_terminate(xbuf, ybuf) 
+        except Exception as ex:
+            print (ex)
+            return False
+
+class callback_mo(object):
+    
+    def __init__(self, 
+                 fun: Callable[[ArrayLike], ArrayLike], 
+                 dim: int, 
+                 nobj: int, 
+                 is_terminate: Optional[bool] = None):
+        self.fun = fun
+        self.dim = dim
+        self.nobj = nobj
+        self.is_terminate = is_terminate
+    
+    def __call__(self, dim: int, x, y):
+        try:
+            arrTypeX = ct.c_double*(dim)
+            xaddr = ct.addressof(x.contents)
+            xbuf = np.frombuffer(arrTypeX.from_address(xaddr))
+            arrTypeY = ct.c_double*(self.nobj)
+            yaddr = ct.addressof(y.contents)   
+            ybuf = np.frombuffer(arrTypeY.from_address(yaddr))  
+            ybuf[:] = self.fun(xbuf)[:]
+            return False if self.is_terminate is None else self.is_terminate(xbuf, ybuf) 
+        except Exception as ex:
+            print (ex)
+            return False
+
+class callback_par(object):
+    
+    def __init__(self, 
+                 fun: Callable[[ArrayLike], float], 
+                 parfun: Callable[[ArrayLike], ArrayLike]):
+        self.fun = fun
+        self.parfun = parfun
+    
+    def __call__(self, popsize, n, xs_, ys_):
+        try:
+            arrType = ct.c_double*(popsize*n)
+            addr = ct.addressof(xs_.contents)
+            xall = np.frombuffer(arrType.from_address(addr))
+            
+            if self.parfun is None:
+                for p in range(popsize):
+                    ys_[p] = self.fun(xall[p*n : (p+1)*n])
+            else:    
+                xs = []
+                for p in range(popsize):
+                    x = xall[p*n : (p+1)*n]
+                    xs.append(x)
+                ys = self.parfun(xs)
+                for p in range(popsize):
+                    ys_[p] = ys[p]
+        except Exception as ex:
+            print (ex)
+
+basepath = os.path.dirname(os.path.abspath(__file__))
+
+try: 
+    if sys.platform.startswith('linux'):
+        libcmalib = ct.cdll.LoadLibrary(basepath + '/lib/libacmalib.so')  
+    elif 'mac' in sys.platform or 'darwin' in sys.platform:
+        libcmalib = ct.cdll.LoadLibrary(basepath + '/lib/libacmalib.dylib')  
+    else:
+        os.environ['PATH'] = (basepath + '/lib') + os.pathsep + os.environ['PATH']
+        libcmalib = ct.cdll.LoadLibrary(basepath + '/lib/libacmalib.dll')
+except Exception as ex:
+    libcmalib = None
+    
+mo_call_back_type = ct.CFUNCTYPE(ct.c_bool, ct.c_int, ct.POINTER(ct.c_double), ct.POINTER(ct.c_double))
+  
+call_back_type = ct.CFUNCTYPE(ct.c_double, ct.c_int, ct.POINTER(ct.c_double))  
+
+call_back_par = ct.CFUNCTYPE(None, ct.c_int, ct.c_int, \
+                                  ct.POINTER(ct.c_double), ct.POINTER(ct.c_double))  
+