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

fcmaes/cmaescpp.py

@@ -13,24 +13,32 @@ import os
 import math
 import ctypes as ct
 import numpy as np
-from numpy.random import MT19937, Generator
-from scipy.optimize import OptimizeResult
-from fcmaes.cmaes import _check_bounds
+from numpy.random import PCG64DXSM, Generator
+from scipy.optimize import OptimizeResult, Bounds
+from fcmaes.evaluator import _check_bounds, _get_bounds, mo_call_back_type, callback_so, callback_par, call_back_par, parallel, libcmalib
+
+from typing import Optional, Callable, Union
+from numpy.typing import ArrayLike
 
 os.environ['MKL_DEBUG_CPU_TYPE'] = '5'
 
-def minimize(fun, 
-             bounds=None, 
-             x0=None, 
-             input_sigma = 0.3, 
-             popsize = 31, 
-             max_evaluations = 100000, 
-             max_iterations = 100000,  
-             accuracy = 1.0, 
-             stop_fittness = None, 
-             is_terminate = None, 
-             rg = Generator(MT19937()),
-             runid=0):   
+def minimize(fun: Callable[[ArrayLike], float], 
+             bounds: Optional[Bounds] = None, 
+             x0: Optional[ArrayLike] = None,
+             input_sigma: Optional[Union[float, ArrayLike, Callable]] = 0.3,
+             popsize: Optional[int] = 31,
+             max_evaluations: Optional[int]  = 100000,
+             accuracy: Optional[float] = 1.0, 
+             stop_fitness: Optional[float] = -np.inf, 
+             stop_hist: Optional[float] = -1,
+             rg: Optional[Generator] = Generator(PCG64DXSM()),
+             runid: Optional[int] = 0,
+             workers: Optional[int] = 1, 
+             normalize: Optional[bool] = True,
+             delayed_update: Optional[bool] = True,
+             update_gap: Optional[int] = None
+             ) -> OptimizeResult:
+   
     """Minimization of a scalar function of one or more variables using a 
     C++ CMA-ES implementation called via ctypes.
      
@@ -38,38 +46,43 @@ 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 (dim,)
     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.
-    x0 : ndarray, shape (n,)
-        Initial guess. Array of real elements of size (n,),
-        where 'n' is the number of independent variables.  
-    input_sigma : ndarray, shape (n,) or scalar
+    x0 : ndarray, shape (dim,)
+        Initial guess. Array of real elements of size (dim,),
+        where 'dim' is the number of independent variables.  
+    input_sigma : ndarray, shape (dim,) or scalar
         Initial step size for each dimension.
     popsize = int, optional
         CMA-ES population size.
     max_evaluations : int, optional
         Forced termination after ``max_evaluations`` function evaluations.
-    max_iterations : int, optional
-        Forced termination after ``max_iterations`` iterations.
     accuracy : float, optional
         values > 1.0 reduce the accuracy.
-    stop_fittness : float, optional 
+    stop_fitness : float, optional 
          Limit for fitness value. If reached minimize terminates.
-    is_terminate : callable, optional
-        Callback to be used if the caller of minimize wants to 
-        decide when to terminate. 
+    stop_hist : float, optional 
+         Set to 0 if you want to prevent premature termination because 
+         there is no progress
     rg = numpy.random.Generator, optional
         Random generator for creating random guesses.
     runid : int, optional
         id used by the is_terminate callback to identify the CMA-ES run. 
-            
+    workers : int or None, optional
+        If not workers is None, function evaluation is performed in parallel for the whole population. 
+        Useful for costly objective functions but is deactivated for parallel retry.      
+    normalize : boolean, optional
+        if true pheno -> geno transformation maps arguments to interval [-1,1]
+    delayed_update : boolean, optional
+        if true uses delayed update / C++ parallelism, i false uses Python multithreading
+    update_gap : int, optional
+        number of iterations without distribution update
+           
     Returns
     -------
     res : scipy.OptimizeResult
@@ -82,72 +95,225 @@ def minimize(fun,
         ``success`` a Boolean flag indicating if the optimizer exited successfully. """
     
     lower, upper, guess = _check_bounds(bounds, x0, rg)      
-    n = guess.size   
-    if lower is None:
-        lower = [0]*n
-        upper = [0]*n
+    dim = guess.size   
+    if workers is None:
+        workers = 0
     mu = int(popsize/2)
+    if callable(input_sigma):
+        input_sigma=input_sigma()
     if np.ndim(input_sigma) == 0:
-        input_sigma = [input_sigma] * n
-    if stop_fittness is None:
-        stop_fittness = math.inf   
-    if is_terminate is None:    
-        is_terminate=_is_terminate_false
-        use_terminate = False 
-    else:
-        use_terminate = True 
-    array_type = ct.c_double * n   
-    c_callback = call_back_type(callback(fun))
-    c_is_terminate = is_terminate_type(is_terminate)
+        input_sigma = [input_sigma] * dim
+    if stop_hist is None:
+        stop_hist = -1;
+    array_type = ct.c_double * dim 
+    c_callback = mo_call_back_type(callback_so(fun, dim))
+    parfun = None if delayed_update == True or workers is None or workers <= 1 else parallel(fun, workers)
+    c_callback_par = call_back_par(callback_par(fun, parfun))
+    res = np.empty(dim+4)
+    res_p = res.ctypes.data_as(ct.POINTER(ct.c_double))
     try:
-        res = optimizeACMA_C(runid, c_callback, n, array_type(*guess), array_type(*lower), array_type(*upper), 
-                           array_type(*input_sigma), max_iterations, max_evaluations, stop_fittness, mu, 
-                           popsize, accuracy, use_terminate, c_is_terminate, int(rg.uniform(0, 2**32 - 1)))
-
-        x = np.array(np.fromiter(res, dtype=np.float64, count=n))
-        val = res[n]
-        evals = int(res[n+1])
-        iterations = int(res[n+2])
-        stop = int(res[n+3])
-        freemem(res)
-        return OptimizeResult(x=x, fun=val, nfev=evals, nit=iterations, status=stop, success=True)
+        optimizeACMA_C(runid, c_callback, c_callback_par, 
+                dim, array_type(*guess), 
+                None if lower is None else array_type(*lower), 
+                None if upper is None else array_type(*upper), 
+                array_type(*input_sigma), max_evaluations, stop_fitness, stop_hist, mu, 
+                popsize, accuracy, int(rg.uniform(0, 2**32 - 1)), 
+                normalize, delayed_update, -1 if update_gap is None else update_gap,
+                workers, res_p)
+        x = res[:dim]
+        val = res[dim]
+        evals = int(res[dim+1])
+        iterations = int(res[dim+2])
+        stop = int(res[dim+3])
+        res = OptimizeResult(x=x, fun=val, nfev=evals, nit=iterations, status=stop, success=True)
     except Exception as ex:
-        return OptimizeResult(x=None, fun=sys.float_info.max, nfev=0, nit=0, status=-1, success=False)
+        res = OptimizeResult(x=None, fun=sys.float_info.max, nfev=0, nit=0, status=-1, success=False)
+    if not parfun is None:
+        parfun.stop()
+    return res
 
-class callback(object):
-    
-    def __init__(self, fun):
-        self.fun = fun
+class ACMA_C:
+
+    def __init__(self,
+        dim, 
+        bounds: Optional[Bounds] = None, 
+        x0: Optional[ArrayLike] = None,
+        input_sigma: Optional[Union[float, ArrayLike, Callable]] = 0.3, 
+        popsize: Optional[int] = 31,  
+        max_evaluations: Optional[int] = 100000, 
+        accuracy: Optional[float] = 1.0, 
+        stop_fitness: Optional[float] = -np.inf, 
+        stop_hist: Optional[float] = -1,
+        rg: Optional[Generator] = Generator(PCG64DXSM()),
+        runid: Optional[int] = 0,
+        normalize: Optional[bool] = True,
+        delayed_update: Optional[bool] = True,
+        update_gap: Optional[int] = None
+     ):
+       
+        """Parameters
+        ----------
+        dim : int
+            dimension of the argument of the objective function
+        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.
+        x0 : ndarray, shape (dim,)
+            Initial guess. Array of real elements of size (dim,),
+            where 'dim' is the number of independent variables.  
+        input_sigma : ndarray, shape (dim,) or scalar
+            Initial step size for each dimension.
+        popsize = int, optional
+            CMA-ES population size.
+        max_evaluations : int, optional
+            Forced termination after ``max_evaluations`` function evaluations.
+        accuracy : float, optional
+            values > 1.0 reduce the accuracy.
+        stop_fitness : float, optional 
+             Limit for fitness value. If reached minimize terminates.
+        stop_hist : float, optional 
+             Set to 0 if you want to prevent premature termination because 
+             there is no progress
+        rg = numpy.random.Generator, optional
+            Random generator for creating random guesses.
+        runid : int, optional
+            id used by the is_terminate callback to identify the CMA-ES run.     
+        normalize : boolean, optional
+            if true pheno -> geno transformation maps arguments to interval [-1,1]
+        delayed_update : boolean, optional
+            if true uses delayed update / C++ parallelism, i false uses Python multithreading
+        update_gap : int, optional
+            number of iterations without distribution update"""
+             
+        lower, upper, guess = _get_bounds(dim, bounds, x0, rg)     
+        if lower is None:
+            lower = [0]*dim
+            upper = [0]*dim
+        mu = int(popsize/2)
+        if callable(input_sigma):
+            input_sigma=input_sigma()
+        if np.ndim(input_sigma) == 0:
+            input_sigma = [input_sigma] * dim
+        if stop_hist is None:
+            stop_hist = -1;
+        array_type = ct.c_double * dim 
+        try:
+            self.ptr = initACMA_C(runid,
+                dim, array_type(*guess), array_type(*lower), array_type(*upper), 
+                array_type(*input_sigma), max_evaluations, stop_fitness, stop_hist, mu, 
+                popsize, accuracy, int(rg.uniform(0, 2**32 - 1)), 
+                normalize, delayed_update, -1 if update_gap is None else update_gap)
+            self.popsize = popsize
+            self.dim = dim            
+        except Exception as ex:
+            print (ex)
+            pass
     
-    def __call__(self, n, x):
+    def __del__(self):
+        destroyACMA_C(self.ptr)
+            
+    def ask(self) -> np.array:
         try:
-            fit = self.fun([x[i] for i in range(n)])
-            return fit if math.isfinite(fit) else sys.float_info.max
-        except Exception:
-            return sys.float_info.max
-
-def _is_terminate_false(runid, iterations, val):
-    return False 
-  
-basepath = os.path.dirname(os.path.abspath(__file__))
+            popsize = self.popsize
+            n = self.dim
+            res = np.empty(popsize*n)
+            res_p = res.ctypes.data_as(ct.POINTER(ct.c_double))
+            askACMA_C(self.ptr, res_p)
+            xs = np.empty((popsize, n))
+            for p in range(popsize):
+                xs[p,:] = res[p*n : (p+1)*n]
+            return xs
+        except Exception as ex:
+            print (ex)
+            return None
 
-if sys.platform.startswith('linux'):
-    libcmalib = ct.cdll.LoadLibrary(basepath + '/lib/libacmalib.so')  
-elif 'mac' in sys.platform:
-    libgtoplib = ct.cdll.LoadLibrary(basepath + '/lib/libacmalib.dylib')  
-else:
-    libcmalib = ct.cdll.LoadLibrary(basepath + '/lib/libacmalib.dll')  
+    def tell(self, 
+             ys: np.ndarray, 
+             xs: Optional[np.ndarray] = None) -> int:  
+        if not xs is None:
+            return self.tell_x_(ys, xs)
+        try:
+            array_type_ys = ct.c_double * len(ys)
+            return tellACMA_C(self.ptr, array_type_ys(*ys))
+        except Exception as ex:
+            print (ex)
+            return -1    
 
-call_back_type = ct.CFUNCTYPE(ct.c_double, ct.c_int, ct.POINTER(ct.c_double))  
-is_terminate_type = ct.CFUNCTYPE(ct.c_bool, ct.c_long, ct.c_int, ct.c_double)    
+    def tell_x_(self, ys: np.ndarray, xs: np.ndarray):
+        try:
+            flat_xs = xs.flatten()
+            array_type_xs = ct.c_double * len(flat_xs)
+            array_type_ys = ct.c_double * len(ys)
+            return tellXACMA_C(self.ptr, array_type_ys(*ys), array_type_xs(*flat_xs))
+        except Exception as ex:
+            print (ex)
+            return -1 
+        
+    def population(self) -> np.array:
+        try:
+            popsize = self.popsize
+            n = self.dim
+            res = np.empty(popsize*n)
+            res_p = res.ctypes.data_as(ct.POINTER(ct.c_double))
+            populationACMA_C(self.ptr, res_p)
+            xs = np.array(popsize, n)
+            for p in range(popsize):
+                xs[p] = res[p*n : (p+1)*n]
+                return xs
+        except Exception as ex:
+            print (ex)
+            return None
 
-optimizeACMA_C = libcmalib.optimizeACMA_C
-optimizeACMA_C.argtypes = [ct.c_long, call_back_type, ct.c_int, \
-            ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), \
-            ct.POINTER(ct.c_double), ct.c_int, ct.c_int, ct.c_double, ct.c_int, ct.c_int, \
-            ct.c_double, ct.c_bool, is_terminate_type, ct.c_long]
+    def result(self) -> OptimizeResult:
+        res = np.empty(self.dim+4)
+        res_p = res.ctypes.data_as(ct.POINTER(ct.c_double))
+        try:
+            resultACMA_C(self.ptr, res_p)
+            x = res[:self.dim]
+            val = res[self.dim]
+            evals = int(res[self.dim+1])
+            iterations = int(res[self.dim+2])
+            stop = int(res[self.dim+3])
+            res = OptimizeResult(x=x, fun=val, nfev=evals, nit=iterations, status=stop, success=True)
+        except Exception as ex:
+            res = OptimizeResult(x=None, fun=sys.float_info.max, nfev=0, nit=0, status=-1, success=False)
+        return res
 
-optimizeACMA_C.restype = ct.POINTER(ct.c_double)         
+if not libcmalib is None: 
 
-freemem = libcmalib.free_mem
-freemem.argtypes = [ct.POINTER(ct.c_double)]
+    optimizeACMA_C = libcmalib.optimizeACMA_C
+    optimizeACMA_C.argtypes = [ct.c_long, mo_call_back_type, call_back_par, ct.c_int, \
+                ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), \
+                ct.POINTER(ct.c_double), ct.c_int, ct.c_double, ct.c_double, ct.c_int, ct.c_int, \
+                ct.c_double, ct.c_long, ct.c_bool, ct.c_bool, ct.c_int, 
+                ct.c_int, ct.POINTER(ct.c_double)]
+    
+    initACMA_C = libcmalib.initACMA_C
+    initACMA_C.argtypes = [ct.c_long, ct.c_int, \
+                ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), \
+                ct.POINTER(ct.c_double), ct.c_int, ct.c_double, ct.c_double, ct.c_int, 
+                ct.c_int, ct.c_double, ct.c_long, ct.c_bool, ct.c_bool, ct.c_int]
+                    
+    initACMA_C.restype = ct.c_void_p   
+    
+    destroyACMA_C = libcmalib.destroyACMA_C
+    destroyACMA_C.argtypes = [ct.c_void_p]
+    
+    askACMA_C = libcmalib.askACMA_C
+    askACMA_C.argtypes = [ct.c_void_p, ct.POINTER(ct.c_double)]
+    
+    tellACMA_C = libcmalib.tellACMA_C
+    tellACMA_C.argtypes = [ct.c_void_p, ct.POINTER(ct.c_double)]
+    tellACMA_C.restype = ct.c_int
+    
+    tellXACMA_C = libcmalib.tellXACMA_C
+    tellXACMA_C.argtypes = [ct.c_void_p, ct.POINTER(ct.c_double), ct.POINTER(ct.c_double)]
+    tellXACMA_C.restype = ct.c_int
+    
+    populationACMA_C = libcmalib.populationACMA_C
+    populationACMA_C.argtypes = [ct.c_void_p, ct.POINTER(ct.c_double)]
+    
+    resultACMA_C = libcmalib.resultACMA_C
+    resultACMA_C.argtypes = [ct.c_void_p, ct.POINTER(ct.c_double)]