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

fcmaes/astro.py

@@ -8,33 +8,27 @@ import math
 import os
 import ctypes as ct
 from scipy.optimize import Bounds
+from fcmaes.decpp import libcmalib
 
-basepath = os.path.dirname(os.path.abspath(__file__))
-if sys.platform.startswith('linux'):   
-    libgtoplib = ct.cdll.LoadLibrary(basepath + '/lib/libgtoplib.so')    
-elif 'mac' in sys.platform:
-    libgtoplib = ct.cdll.LoadLibrary(basepath + '/lib/libgtoplib.dylib')  
-else:
-    os.environ['PATH'] = (basepath + '/lib') + os.pathsep + os.environ['PATH']
-    libgtoplib = ct.cdll.LoadLibrary(basepath + '/lib/libgtoplib.dll')
-
-freemem = libgtoplib.free_mem
-freemem.argtypes = [ct.POINTER(ct.c_double)]
-
-# for windows compatibility. Linux can pickle c pointers, windows can not
-astro_map = {  
-    "messengerfullC": libgtoplib.messengerfullC,
-    "messengerC": libgtoplib.messengerC,
-    "gtoc1C": libgtoplib.gtoc1C,
-    "cassini1C": libgtoplib.cassini1C,
-    "cassini1minlpC": libgtoplib.cassini1minlpC,
-    "cassini2C": libgtoplib.cassini2C,
-    "rosettaC": libgtoplib.rosettaC,
-    "sagasC": libgtoplib.sagasC,
-    "tandemC": libgtoplib.tandemC,
-    "tandemCu": libgtoplib.tandemCu
+if not libcmalib is None: 
+    
+    astro_map = {  
+        "messengerfullC": libcmalib.messengerfullC,
+        "messengerC": libcmalib.messengerC,
+        "gtoc1C": libcmalib.gtoc1C,
+        "cassini1C": libcmalib.cassini1C,
+        "cassini1minlpC": libcmalib.cassini1minlpC,
+        "cassini2C": libcmalib.cassini2C,
+        "rosettaC": libcmalib.rosettaC,
+        "sagasC": libcmalib.sagasC,
+        "tandemC": libcmalib.tandemC,
+        "tandemCu": libcmalib.tandemCu,
+        "cassini2minlpC": libcmalib.cassini2minlpC,
     }
 
+    freemem = libcmalib.free_mem
+    freemem.argtypes = [ct.POINTER(ct.c_double)]    
+    
 class Astrofun(object):
     """Provides access to ESAs GTOP optimization test functions."""
     def __init__(self, name, fun_c, lower, upper):    
@@ -191,18 +185,33 @@ class Cassini1multi(object):
 class Cassini1minlp(object):
     """ see https://www.esa.int/gsp/ACT/projects/gtop/cassini1/ """
     
-    def __init__(self, weights = [1,0,0,0]):    
-        Astrofun.__init__(self, 'Cassini1minlp', "Cassini1minlpC", 
-                           [-1000.,30.,100.,30.,400.,1000., 1.0,1.0,1.0,1.0 ],
-                           [0.,400.,470.,400.,2000.,6000., 9.0,9.0,9.0,9.0 ]       
+    def __init__(self, planets = [2,2,3,5]):    
+        Astrofun.__init__(self, 'Cassini1', "cassini1C", 
+                           [-1000.,30.,100.,30.,400.,1000.],
+                           [0.,400.,470.,400.,2000.,6000.]       
         )
-        self.fun = self.cassini1minlp
-        self.weights = weights
-        self.mfun = cassini1multi
-         
-    def cassini1minlp(self, x):
-        r = cassini1multi(x)
-        return self.weights[0]*r[0] + self.weights[1]*r[1] + self.weights[2]*r[2] + self.weights[3]*r[3]
+        self.fun = self.cassini1
+        self.planets = planets
+   
+    def cassini1(self, x):
+        return cassini1minlp(list(x) + self.planets)
+      
+def cassini1minlp(x):
+    n = len(x)
+    array_type = ct.c_double * n   
+    fun_c = astro_map["cassini1minlpC"]      
+    fun_c.argtypes = [ct.c_int, ct.POINTER(ct.c_double)]
+    fun_c.restype = ct.POINTER(ct.c_double)  
+    try: # function is only defined inside bounds
+        res = fun_c(n, array_type(*x))
+        dv = res[0]
+        freemem(res)
+        if not math.isfinite(dv):
+            dv = 1E10
+    except Exception as ex:
+        print(ex)
+        dv = 1E10
+    return dv
 
 def cassini1multi(x):
     n = len(x)
@@ -218,13 +227,28 @@ def cassini1multi(x):
         if not math.isfinite(dv):
             dv = 1E10
     except Exception as ex:
+        print(ex)
         dv = 1E10
         launch_dv = 1E10 
-    tof = x[1] + x[2] + x[3] + x[4]
+    tof = sum(x[1:6])
     launch_time = x[0] 
-    return [dv, tof, launch_time, launch_dv]
+    return [dv, tof, launch_time]
 
-  
+def cassini2multi(x):
+    n = len(x)
+    array_type = ct.c_double * n   
+    fun_c = astro_map["cassini2minlpC"]      
+    fun_c.argtypes = [ct.c_int, ct.POINTER(ct.c_double)]
+    fun_c.restype = ct.c_double  
+    try: # function is only defined inside bounds
+        dv = fun_c(n, array_type(*x))
+    except Exception as ex:
+        print(ex)
+        dv = 1E99
+    tof = sum(x[4:9])
+    launch_time = x[0] 
+    return [dv, tof, launch_time]
+ 
 class python_fun(object):
     
     def __init__(self, cfun, bounds):
@@ -242,5 +266,5 @@ class python_fun(object):
                 val = 1E10
         except Exception as ex:
             val = 1E10
-        return val
-    
+        return val 
+

fcmaes/bitecpp.py

@@ -13,23 +13,25 @@ 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 fcmaes.cmaescpp import libcmalib
-from fcmaes.decpp import mo_call_back_type, callback
+from numpy.random import PCG64DXSM, Generator
+from scipy.optimize import OptimizeResult, Bounds
+from fcmaes.evaluator import _check_bounds, mo_call_back_type, callback_so, libcmalib
+
+from typing import Optional, Callable
+from numpy.typing import ArrayLike
 
 os.environ['MKL_DEBUG_CPU_TYPE'] = '5'
 
-def minimize(fun, 
-             bounds=None, 
-             x0=None, 
-             popsize = 0, 
-             max_evaluations = 100000, 
-             stop_fitness = None, 
-             M = 1,
-             rg = Generator(MT19937()),
-             runid=0):   
+def minimize(fun: Callable[[ArrayLike], float],
+             bounds: Optional[Bounds] = None,
+             x0: Optional[ArrayLike] = None,
+             max_evaluations: Optional[int] = 100000,
+             stop_fitness: Optional[float] = -np.inf,
+             M: Optional[int] = 1,
+             popsize: Optional[int] = 0,
+             stall_criterion: Optional[int]  = 0,
+             rg: Optional[Generator]  = Generator(PCG64DXSM()),
+             runid: Optional[int] = 0) -> OptimizeResult:
     """Minimization of a scalar function of one or more variables using a 
     C++ SCMA implementation called via ctypes.
      
@@ -37,10 +39,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 (dim,) 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.
@@ -49,14 +49,16 @@ def minimize(fun,
     x0 : ndarray, shape (dim,)
         Initial guess. Array of real elements of size (dim,),
         where 'dim' is the number of independent variables.  
-    popsize = int, optional
-        CMA-ES population size.
     max_evaluations : int, optional
         Forced termination after ``max_evaluations`` function evaluations.
     stop_fitness : float, optional 
          Limit for fitness value. If reached minimize terminates.
     M : int, optional 
         Depth to use, 1 for plain CBiteOpt algorithm, >1 for CBiteOptDeep. Expected range is [1; 36].
+    popsize = int, optional
+        initial population size.
+    stall_criterion : int, optional 
+        Terminate if stall_criterion*128*evaluations stalled, Not used if <= 0
     rg = numpy.random.Generator, optional
         Random generator for creating random guesses.
     runid : int, optional
@@ -75,19 +77,16 @@ def minimize(fun,
     
     lower, upper, guess = _check_bounds(bounds, x0, rg)      
     dim = guess.size   
-    if lower is None:
-        lower = [0]*dim
-        upper = [0]*dim
-    if stop_fitness is None:
-        stop_fitness = -math.inf   
     array_type = ct.c_double * dim 
-    c_callback = mo_call_back_type(callback(fun, dim))
+    c_callback = mo_call_back_type(callback_so(fun, dim))
     res = np.empty(dim+4)
     res_p = res.ctypes.data_as(ct.POINTER(ct.c_double))
     try:
         optimizeBite_C(runid, c_callback, dim, int(rg.uniform(0, 2**32 - 1)), 
-                           array_type(*guess), array_type(*lower), array_type(*upper), 
-                           max_evaluations, stop_fitness, popsize, M, res_p)
+                           None if x0 is None else array_type(*guess), 
+                           None if lower is None else array_type(*lower), 
+                           None if upper is None else array_type(*upper), 
+                           max_evaluations, stop_fitness, M, popsize, stall_criterion, res_p)
         x = res[:dim]
         val = res[dim]
         evals = int(res[dim+1])
@@ -97,10 +96,12 @@ def minimize(fun,
     except Exception as ex:
         return OptimizeResult(x=None, fun=sys.float_info.max, nfev=0, nit=0, status=-1, success=False)
 
-optimizeBite_C = libcmalib.optimizeBite_C
-optimizeBite_C.argtypes = [ct.c_long, mo_call_back_type, ct.c_int, ct.c_int, \
-            ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), \
-            ct.c_int, ct.c_double, ct.c_int, ct.c_int, ct.POINTER(ct.c_double)]
+if not libcmalib is None: 
+    
+    optimizeBite_C = libcmalib.optimizeBite_C
+    optimizeBite_C.argtypes = [ct.c_long, mo_call_back_type, ct.c_int, ct.c_int, \
+                ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), \
+                ct.c_int, ct.c_double, ct.c_int, ct.c_int, ct.c_int, ct.POINTER(ct.c_double)]
        
 
 

fcmaes/cmaes.py

@@ -16,38 +16,39 @@ from time import time
 import ctypes as ct
 import multiprocessing as mp
 from scipy import linalg
-from scipy.optimize import OptimizeResult
-from numpy.random import MT19937, Generator
-from fcmaes.evaluator import Evaluator
+from scipy.optimize import OptimizeResult, Bounds
+from numpy.random import PCG64DXSM, Generator
+from fcmaes.evaluator import Evaluator, serial, _check_bounds, _fitness, is_debug_active
+
+from loguru import logger
+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,  
-             workers = 1,
-             accuracy = 1.0, 
-             stop_fitness = np.nan, 
-             is_terminate = None, 
-             rg = Generator(MT19937()),
-             runid=0,
-             normalize = True,
-             update_gap = None,
-             logger = None):       
+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,
+             max_iterations: Optional[int]  = 100000,
+             workers: Optional[int]  = 1,
+             accuracy: Optional[float] = 1.0,
+             stop_fitness: Optional[float] = -np.inf,
+             is_terminate: Optional[Callable[[ArrayLike, float], bool]]  = None,
+             rg: Optional[Generator] = Generator(PCG64DXSM()),
+             runid: Optional[int] = 0,
+             normalize: Optional[bool] = True,
+             update_gap: Optional[int] = None) -> OptimizeResult:
     """Minimization of a scalar function of one or more variables using CMA-ES.
      
     Parameters
     ----------
     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.
@@ -82,10 +83,6 @@ def minimize(fun,
         pheno -> if true geno transformation maps arguments to interval [-1,1] 
     update_gap : int, optional
         number of iterations without distribution update
-    logger : logger, optional
-        logger for log output for tell_one, If None, logging
-        is switched off. Default is a logger which logs both to stdout and
-        appends to a file ``optimizer.log``.
    
     Returns
     -------
@@ -103,7 +100,7 @@ def minimize(fun,
                       max_evaluations, max_iterations, 
                       accuracy, stop_fitness, 
                       is_terminate, rg, np.random.randn, runid, normalize, 
-                      update_gap, fun, logger)        
+                      update_gap, fun)        
     if workers and workers > 1:
         x, val, evals, iterations, stop = cmaes.do_optimize_delayed_update(fun, workers=workers)
     else:      
@@ -114,22 +111,21 @@ def minimize(fun,
 class Cmaes(object):
     """Implements the cma-es ask/tell interactive interface."""
     
-    def __init__(self, bounds=None, 
-                        x0=None, 
-                        input_sigma = 0.3, 
-                        popsize = 31, 
-                        max_evaluations = 100000, 
-                        max_iterations = 100000,  
-                        accuracy = 1.0, 
-                        stop_fitness = np.nan, 
-                        is_terminate = None, 
-                        rg = Generator(MT19937()), # used if x0 is undefined
-                        randn = np.random.randn, # used for random offspring 
-                        runid=0, 
-                        normalize = False,
-                        update_gap = None,
-                        fun = None,
-                        logger = None
+    def __init__(self, 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,
+                        max_iterations: Optional[int] = 100000,
+                        accuracy: Optional[int] = 1.0,
+                        stop_fitness: Optional[float] = -np.inf,
+                        is_terminate: Optional[bool] = None,
+                        rg: Optional[Generator] = Generator(PCG64DXSM()), # used if x0 is undefined
+                        randn: Optional[Callable] = np.random.randn, # used for random offspring 
+                        runid: Optional[int] = 0,
+                        normalize: Optional[bool] = True,
+                        update_gap: Optional[int] = None,
+                        fun: Optional[Callable[[ArrayLike], float]] = None
                         ):
                         
     # runid used in is_terminate callback to identify a specific run at different iteration
@@ -187,9 +183,8 @@ class Cmaes(object):
     # selection strategy parameters
     # Number of parents/points for recombination.
         self.mu = int(self.popsize/2)
-    # logger / timing / global best value    
-        if not logger is None:
-            self.logger = logger
+    # timing / global best value    
+        if is_debug_active():
             self.best_y = mp.RawValue(ct.c_double, 1E99)
             self.n_evals = mp.RawValue(ct.c_long, 0)
             self.time_0 = time()
@@ -257,7 +252,7 @@ class Cmaes(object):
         self.arz = None
         self.fitness = None
 
-    def ask(self):
+    def ask(self) -> np.array:
         """ask for popsize new argument vectors.
             
         Returns
@@ -265,9 +260,11 @@ class Cmaes(object):
         xs : popsize sized list of dim sized argument lists."""
 
         self.newArgs()
-        return [self.fitfun.decode(x) for x in self.arx]
+        return np.array([self.fitfun.decode(x) for x in self.arx])
  
-    def tell(self, ys, xs = None):      
+    def tell(self, 
+             ys: np.ndarray, 
+             xs: Optional[np.ndarray] = None) -> int:      
         """tell function values for the argument lists retrieved by ask().
     
         Parameters
@@ -297,8 +294,16 @@ class Cmaes(object):
         self.updateCMA()
         self.arz = None
         return self.stop
- 
-    def ask_one(self):
+    
+    def population(self) -> np.array:
+        return self.fitfun.decode(self.arx)
+
+    def result(self) -> OptimizeResult:
+        return OptimizeResult(x=self.best_x, fun=self.best_value, 
+                              nfev=self.fitfun.evaluation_counter, 
+                              nit=self.iterations, status=self.stop, success=True)
+        
+    def ask_one(self) -> np.array:
         """ask for one new argument vector.
         
         Returns
@@ -309,7 +314,9 @@ class Cmaes(object):
         arx = self.fitfun.closestFeasible(self.xmean + delta.transpose())  
         return self.fitfun.decode(arx)
 
-    def tell_one(self, y, x):      
+    def tell_one(self,
+                 y: float, 
+                 x: np.array) -> int:      
         """tell function value for a argument list retrieved by ask_one().
     
         Parameters
@@ -341,7 +348,7 @@ class Cmaes(object):
             self.arx = []
             self.fitness = []
         
-        if hasattr(self, 'logger'):
+        if is_debug_active():
             self.n_evals.value += 1
             if y < self.best_y.value or self.n_evals.value % 1000 == 999:           
                 if y < self.best_y.value: self.best_y.value = y
@@ -349,12 +356,10 @@ class Cmaes(object):
                 c = self.n_evals.value
                 message = '"c/t={0:.2f} c={1:d} t={2:.2f} y={3:.5f} yb={4:.5f} x={5!s}'.format(
                     c/t, c, t, y, self.best_y.value, x)
-                self.logger.info(message)
+                logger.debug(message)
         return self.stop                
            
     def newArgs(self):
-        self.xmean = self.fitfun.closestFeasible(self.xmean)
-        self.fitness = np.full(self.popsize, math.inf)
         # generate random offspring
         self.arz = self.randn(self.popsize, self.dim)    
         delta = (self.BD @ self.arz.transpose()) * self.sigma
@@ -397,10 +402,9 @@ class Cmaes(object):
             self.iterations += 1
             if self.fitfun.evaluation_counter > self.max_evaluations:
                 break
-            # Generate and evaluate popsize offspring
-            self.newArgs()            
-            self.fitness = self.fitfun.values(self.arx)
-            self.updateCMA()
+            xs = self.ask()
+            ys = self.fitfun.values(xs)
+            self.tell(ys, xs)
             if self.stop != 0:
                 break
         return self.best_x, self.best_value, self.fitfun.evaluation_counter, self.iterations, self.stop 
@@ -416,10 +420,9 @@ class Cmaes(object):
         if self.best_value > best_fitness:
             self.best_value = best_fitness
             self.best_x = self.fitfun.decode(self.arx[arindex[0]])    
-            if self.stop_fitness != None: # only if stop_fitness is defined
-                if best_fitness < self.stop_fitness:
-                    self.stop = 1
-                    return 
+            if best_fitness < self.stop_fitness:
+                self.stop = 1
+                return 
 
         # Calculate new xmean, this is selection and recombination
         xold = self.xmean # for speed up of Eq. (2) and (3)
@@ -591,80 +594,4 @@ class Cmaes(object):
             self.diagD = np.sqrt(self.diagD) # diagD contains standard deviations now
             
             self.BD = self.B * self.diagD # O(n^2)
-
-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
-                        
-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)
-
-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([self.decode(X) for X in 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.maximum(np.minimum(X, 1.0), -1.0)
-            else:
-                return np.maximum(np.minimum(X, self.upper), self.lower)
-
-    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
-         
+