coco-experiment 2.8.3__tar.gz → 2.8.4__tar.gz

{coco_experiment-2.8.3 → coco_experiment-2.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: coco-experiment
-Version: 2.8.3
+Version: 2.8.4
 Summary: Benchmarking framework for all types of black-box optimization algorithms.
 Project-URL: Homepage, https://github.com/numbbo/coco-experiment
 Project-URL: Documentation, https://numbbo.github.io/coco-doc/apidocs/cocoex/

{coco_experiment-2.8.3 → coco_experiment-2.8.4}/src/cocoex/_version.py

@@ -1,7 +1,7 @@
 # file generated by fabricate
 # Do not change, do not track in version control!
 
-__version__ = "2.8.3"
+__version__ = "2.8.4"
 version = __version__
 
 if __name__ == "__main__":

{coco_experiment-2.8.3 → coco_experiment-2.8.4}/src/cocoex/coco.c

@@ -31553,7 +31553,7 @@ void coco_archive_free(coco_archive_t *archive) {
  * don't change, don't track in version control!
  */
 
-const char *coco_version = "2.8.3";
+const char *coco_version = "2.8.4";
 #line 1 "coco_runtime_c.c"
 /**
  * @file coco_runtime_c.c

{coco_experiment-2.8.3 → coco_experiment-2.8.4}/src/cocoex/interface.pyx

@@ -83,6 +83,7 @@ cdef extern from "coco.h":
     void bbob_problem_best_parameter_print(const coco_problem_t *problem)
     void bbob_biobj_problem_best_parameter_print(const coco_problem_t *problem)
 
+cdef extern double coco_problem_get_best_value(coco_problem_t *p)  # copied from bare_problem.pyx
 
 cdef bytes _bstring(s):
     if type(s) is bytes:
@@ -556,7 +557,7 @@ cdef class Problem:
             raise RuntimeError("Problem already initialized")
         if problem == NULL:
             raise ValueError("in Problem._initialize(problem,...): problem is NULL")
-        self.problem = problem
+        self.problem = problem  # should probably be private ._problem?
         self._problem_index = coco_problem_get_suite_dep_index(self.problem)
         self._do_free = free
         self._list_of_observers = []
@@ -783,6 +784,12 @@ cdef class Problem:
         """
         assert(self.problem)
         return bool(coco_problem_final_target_hit(self.problem))
+    @property
+    def _best_value(self):
+        """return best f-value
+        """
+        assert(self.problem)
+        return coco_problem_get_best_value(self.problem)
     #@property
     #def final_target_fvalue1(self):
     #    assert(self.problem)

{coco_experiment-2.8.3 → coco_experiment-2.8.4}/src/cocoex/noiser.py

@@ -8,8 +8,12 @@ import json
 import numpy as np  # for checking finite values
 
 _frozen_noise = True
-math_floor = int
 parameters_file = 'noiser_parameters.json'
+'''default file name where to save current parameters of `Noisifier`'''
+save_parameters = False
+'''flag whether `Noisifier.__init__` saves noise parameters in file'''
+
+math_floor = int
 
 def rand(x, i=0):
     """return a uniform random value seeded with ``x[:2]`` and `i`"""
@@ -20,7 +24,7 @@ def randn(x, i=0):
 def randc(x, i=0):
     """return a Cauchy random value seeded with ``x[:2]`` and `i`.
 
-    We observe that median |Z| = 1 and p(pi x Z / 2 > a) = 1/a.
+    We observe that ``median(|Z|) == 1`` and ``p(pi x Z / 2 > a) == 1/a``.
     """
     return _cauchy(1, _seed(x, i))[0]
 
@@ -71,6 +75,10 @@ class Noisifier:
     noise generator and the numbers scaled by pi/2 such that P(number > k)
     equals about 1/k when k >= 5.
 
+    Parameter settings are by default saved to the file indicated by the module
+    global variable `cocoex.noiser.parameters_file` if
+    ``bool(cocoex.noiser.save_parameters) is True``.
+
     A minimal regression test:
 
     >>> import cocoex
@@ -95,7 +103,7 @@ class Noisifier:
     """
     p_add_single_default = 0.2
     def __init__(self, p_add=None, p_subtract=0.0, p_epsilon=0.0, epsilon=1e-4,
-                 rands=(rand, randn, randc)):
+                 rands=(rand, randn, randc), filename=None):
         """constructor with 4 optional parameters for the noise model,
 
         `p_add`: probability for adding a positive heavy tail random value
@@ -108,6 +116,11 @@ class Noisifier:
         `p_epsilon`: probability for adding a Gaussian random value
 
         `epsilon`: standard deviation of the Gaussian random value
+
+        `filename`: for saving parameter setting, if not given use module global
+        variable `cocoex.noiser.parameters_file`, saving depends on the module
+        variable `save_parameters`.
+
         """
         if p_add is None:
             if p_subtract == p_epsilon == 0:
@@ -116,15 +129,17 @@ class Noisifier:
                 p_add = 0.0
         self._params = {k: v for k, v in locals().items() if k != 'self'}
         if sum(self._params[p] for p in ('p_subtract', 'p_add')) > 1:
-            warnings.warn("p_subtract={0} + p_add={1} > 1, hence p_add is interpreted"
-                          " as ``1-p_subtract``"
+            warnings.warn("p_subtract={0} + p_add={1} > 1, hence p_add"  # noqa: UP030
+                          " is interpreted as ``1-p_subtract``"
                           .format(self._params['p_subtract'], self._params['p_add']))
         if p_add < 0 or p_subtract < 0 or p_epsilon < 0 or epsilon < 0:
-            raise ValueError("parameters cannot be negative but were {0}"
-                             .format(self._params))
+            raise ValueError("parameters cannot be negative"  # noqa: UP030, UP032
+                             " but were {0}".format(self._params))
         if p_epsilon > 0 and epsilon == 0:
-            warnings.warn("p_epsilon = {0} > 0 is not effective because epsilon = 0"
-                          .format(p_epsilon))
+            warnings.warn("p_epsilon = {0} > 0 is not effective"  # noqa: UP030, UP032
+                          " because epsilon = 0".format(p_epsilon))
+        if save_parameters:
+            self.save_parameters()
 
     def noisify(self, problem):
         """wrap `problem` with frozen noise"""
@@ -135,23 +150,19 @@ class Noisifier:
     def parameters(self):
         return {k: v for (k, v) in self._params.items() if k.startswith(('p_', 'eps'))}
 
-    def _dump_params(self):
-        with open(parameters_file, 'wt') as fp:
+    def save_parameters(self, filename=None):
+        """save parameter `dict` to a `json` file"""
+        with open(filename or self._params.get('filename')
+                           or parameters_file, 'wt') as fp:
             json.dump(self.parameters, fp)
 
-    def _load_params(self, filename=parameters_file, warn_errors=(FileNotFoundError,), ignore_errors=()):
-        try:
-            with open(parameters_file, 'rt') as fp:
-                return json.load(fp)
-        except warn_errors as e:
-            warnings.warn('NoisifyProblem._load_params raised the exception "{0}"'.format(e))
-        except ignore_errors:
-            pass
-        return {}
+    def _set_params(self, filename=None, **kwargs):
+        """set parameters from file `filename` or filename passed at
 
-    def _set_params(self, filename=parameters_file, **kwargs):
-        """set parameters from file `filename`"""
-        self._params.update(self._load_params(filename), **kwargs)
+        instantiation or `cocoex.noiser.parameters_file`.
+        """
+        self._params.update(_read_params(filename or self._params.get('filename')
+                                                  or parameters_file), **kwargs)
 
     def __getattr__(self, name):
         """pretend to be a COCO `problem` as passed in `noisify`"""
@@ -211,6 +222,20 @@ class Noisifier:
         assert np.isfinite(n)
         return n
 
+
+def _read_params(filename=None,
+                 warn_errors=(FileNotFoundError,), ignore_errors=()):
+    """read parameters from a json file and return a parameters `dict`"""
+    try:
+        with open(filename or parameters_file, 'rt') as fp:
+            return json.load(fp)
+    except warn_errors as e:
+        warnings.warn('noiser._read_params raised the exception: ' + str(e))
+    except ignore_errors:
+        pass
+    return {}
+
+
 _seed_weights = [1.23468, 2.34579]  # otherwise, coordinate search would be noisefree
 _seeds = collections.deque(maxlen=99)  # for the record only
 def _seed(x, i=0):

{coco_experiment-2.8.3 → coco_experiment-2.8.4}/src/cocoex/utilities.py

@@ -600,6 +600,9 @@ class ExperimentRepeater:
     sweeps until some given budget is exhaused, namely, ``budget_multiplier
     * dimension``.
 
+    CAVEAT: this works as desired only when all instances of the same problem
+    are run in the same batch, as it is the case with `BatchScheduler`.
+
     Example code snippet::
 
         [...]
@@ -934,6 +937,9 @@ class ExperimentRepeater:
 class BatchScheduler:
     """Facilitate to run a benchmarking experiment in independent batches.
 
+    All instances of the same ``(function, dimension)`` belong to the same
+    batch, in order to allow for uniform instance repetitions.
+
     The batch scheduler crucially assumes that in each batch the same
     problems are given *in the same order* when calling `is_in_batch`.
 
@@ -953,10 +959,13 @@ class BatchScheduler:
     ``batch_to_execute in (0,1,2,3)`` to generate the full experimental
     data.
 
-    Details: to get a more even time distribution over all batches, it
-    seems advisable that the number of functions is not divisible by the
-    number of batches. That is, 4 (or 6 or 8 or 12) batches is not likely
-    to be ideal on the `'bbob'` testbed of 24 functions.
+    Details: while making the number of functions not divisible by the number of
+    batches may sometimes achieve a more even time distribution over all
+    batches, in practice, it is advisable to keep each function in a single or a
+    few batches as it is enforced by the `BatchScheduler`. Hence, for the 24
+    functions of the `'bbob'` testbed, having 48 or 24 or 12 or 8 or 6 or 4
+    batches is advisable. Additionally, it can be useful to run the largest
+    dimension in a separate launch (with at most 24 batches in this case).
     """
     def __init__(self, number_of_batches, batch_to_execute):
         """distribute over `number_of_batches` batches and execute