coco-experiment 2.7.1__tar.gz → 2.7.3__tar.gz

{coco_experiment-2.7.1 → coco_experiment-2.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coco-experiment
-Version: 2.7.1
+Version: 2.7.3
 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.7.1 → coco_experiment-2.7.3}/src/cocoex/_version.py

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

{coco_experiment-2.7.1 → coco_experiment-2.7.3}/src/cocoex/coco.c

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

{coco_experiment-2.7.1 → coco_experiment-2.7.3}/src/cocoex/noiser.py

@@ -33,12 +33,12 @@ class Noisifier:
     - adding a value (leading to bad outliers)
     - adding a small `epsilon` normally distributed noise
 
-    The noise is frozen in x and y: whether it's applied and its
-    sampled value depend deterministically on the input x and i.
+    The noise is frozen in x and y: whether the noise is applied to y and
+    its value depend both _deterministically_ on the input x.
 
-    The outlier noise distribution is a Cauchy distribution multiplied by
-    pi/2, which generates values larger than k with a probability awfully
-    close to k**-1 when k >= 10.
+    The outlier noise distribution is a half Cauchy distribution multiplied
+    by pi/2, which generates values larger than k with a probability
+    awfully close to 1/k when k >= 10.
 
     Example::
 
@@ -63,23 +63,41 @@ class Noisifier:
     of the original problem.
 
     Details: the random number generators can be passed as argument and
-    need to obey the interface of `noiser.rand`. ``rands[0]`` is assumed to
-    be uniform in [0,1], ``rands[1]`` is used to sample the Gaussian noise,
-    ``abs(rands[2])`` is used to sample added noise and ``abs(rands[-1])``
-    is used to sample subtracted noise, both of which are assumed to be
-    absolute Cauchy numbers scaled by pi/2 such that P(number > a) equals
-    about 1/a when a >= 5.
+    need to obey the interface of `noiser.rand`. By default, ``rands[0]``
+    is uniform in [0,1] and ``rands[1]`` is Gaussian noise,
+    ``abs(rands[2])`` and ``abs(rands[-1])`` are used to sample added and
+    subtracted noise, respectively. Both are by default the same Cauchy
+    noise generator and the numbers scaled by pi/2 such that P(number > k)
+    equals about 1/k when k >= 5.
 
-    See https://github.com/numbbo/coco-experiment/blob/main/build/python/example/example_experiment_complete.py
+    See also https://github.com/numbbo/coco-experiment/blob/main/build/python/example/example_experiment_complete.py
 
     """
     def __init__(self, p_add=0.2, p_subtract=0.0, p_epsilon=0, epsilon=1e-4,
                  rands=(rand, randn, randc)):
+        """constructor with 4 optional parameters for the noise model,
+
+        `p_add`: probability for adding a positive heavy tail random value
+        making the solution look worse than it is.
+
+        `p_subtract`: probability for subtracting a positive heavy tail
+        random value making the solution look better than it is.
+
+        `p_epsilon`: probability for adding a Gaussian random value
+
+        `epsilon`: standard deviation of the Gaussian random value
+        """
         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``"
                           .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))
+        if p_epsilon > 0 and epsilon == 0:
+            warnings.warn("p_epsilon = {0} > 0 is not effective because epsilon = 0"
+                          .format(p_epsilon))
 
     def noisify(self, problem):
         """wrap `problem` with frozen noise"""
@@ -113,7 +131,12 @@ class Noisifier:
         return getattr(self._problem, name)
 
     def __call__(self, x):
-        return self._fnoise(x) + self._problem(x)
+        fval = self._problem(x)
+        try:  # as quick as hasattr(fval, '__iter__')
+            en = enumerate(fval)  # multiobjective
+        except TypeError:
+            return fval + self._fnoise(x)  # single objective
+        return np.array([f + self._fnoise([x[0] + 1.001 * i, x[1]]) for i, f in en])
 
     def constraint(self, x):
         """return noisy constraint values"""
@@ -122,11 +145,14 @@ class Noisifier:
             constraint[i] += self._cnoise([x[i % 2], c])
         return constraint
 
-    def rand1(self, x, fac=1):
+    def rand0(self, x, fac=1):
+        """uniform by default"""
         return self._params['rands'][0](x, fac)
-    def rand2(self, x, fac=1):
+    def rand1(self, x, fac=1):
+        """Gaussian by default"""
         return self._params['rands'][1](x, fac)
-    def rand3(self, x, fac=1):
+    def rand2(self, x, fac=1):
+        """Cauchy by default"""
         return self._params['rands'][2](x, fac)
 
     def _cnoise(self, x):
@@ -135,24 +161,24 @@ class Noisifier:
     def _fnoise(self, x):
         """x-dependent abs Cauchy noise with median pi/2"""
         n = 0  # no noise by default
-        if self._params['p_epsilon'] > 0 and self.rand1(x, 3) < self._params['p_epsilon']:
-            n = self._params['epsilon'] * self.rand2(x)
+        if self._params['p_epsilon'] > 0 and self.rand0(x, 3) < self._params['p_epsilon']:
+            n = self._params['epsilon'] * self.rand1(x)
         assert np.isfinite(n)
         if all(self._params[p] <= 0 for p in ('p_add', 'p_subtract')):
             return n
-        r = self.rand1(x, 2)  # a uniform random number
+        r = self.rand0(x, 2)  # a uniform random number
         assert 0 <= r <= 1, r
         i = 4
-        for s, p, irand in [(1, 'p_add', 2), (-1, 'p_subtract', -1)]:
-            p = self._params[p]
+        for p, fac, irand in [(self._params['p_add'], 1.5707963267948966, 2),
+                              (self._params['p_subtract'], -1.5707963267948966, -1)]:
             if r < p:
                 assert p > 0, (r, p)
                 nn = self._params['rands'][irand](x, i)
                 if nn < 0:
                     nn *= -1
-                return n + s * 3.141592653589793 / 2 * nn
+                return n + fac * nn
                         # self.randn(x, 2) / self.randn(x, 12)
-                # was: return n + s * 2 * r / self._params[p] / self.rand1(x)
+                # was: return n + s * 2 * r / self._params[p] / self.rand0(x)
             r = 1 - r  # prevent sampling another r
             i += 1  # not clear why we need to change i
         assert np.isfinite(n)

{coco_experiment-2.7.1 → coco_experiment-2.7.3}/src/cocoex/utilities.py

@@ -647,8 +647,9 @@ class ExperimentRepeater:
     When problem instances are repeated in a single suite, they may be
     *partially* skipped *after* the first full sweep. That is, the
     configuration ``1-5,1-5,1-5`` can also lead to four trials of each
-    instance 1-5, because all instances have been repeated the same number
-    of times.
+    instance 1-5 of some problems when all instances have been repeated the
+    same number of times and have enough successes or the budget is
+    exhaused.
 
     >>> import cocoex  # some not very meaningful testing
     >>> repeater = cocoex.ExperimentRepeater(2)
@@ -658,18 +659,31 @@ class ExperimentRepeater:
     >>> assert len(repeater.evaluations((1, 2))) == 0
 
     """
-    def __init__(self, budget_multiplier, min_successes=None):
-        """``min_successes=11`` is default and provokes at least three
-
-        sweeps when the suite has (only) 5 instance and the
-        `budget_multiplier` is large enough such that the algorithm
-        terminates the second sweep before the overall budget is exhausted.
-        This would emulate the 3 x 1-5 instance-setup from BBOB 2009,
-        however the choice of the initial solution still slightly differs.
+    min_successes_default = 11
+    max_sweeps_default = 20
+    def __init__(self, budget_multiplier, min_successes=None, max_sweeps=None):
+        """constructor for `ExperimentRepeater`.
+
+        The "timeout" budget is computed as ``budget_multiplier`` times
+        problem dimension.
+
+        ``min_successes=11`` is default and provokes at least three sweeps
+        when the suite has (only) 5 instance and the `budget_multiplier` is
+        large enough such that the algorithm terminates the second sweep
+        before the overall budget is exhausted. This would emulate the 3 x
+        1-5 instance-setup from BBOB 2009, however the choice of the
+        initial solution still slightly differs.
+
+        ``max_sweeps`` is the limit number of repititions for each
+        instance, by default 20. To have a limit is in particular useful
+        when the budget is large but an algorithm terminates very quickly
+        and invariably unsuccessfully.
         """
         self.params = {k: v for k, v in locals().items() if k != 'self'}
-        self.min_successes = 11 if min_successes is None else min_successes
-        self.max_sweeps = 1e4  # should not be necessary
+        self.min_successes = ExperimentRepeater.min_successes_default if (
+                min_successes is None) else min_successes
+        self.max_sweeps = ExperimentRepeater.max_sweeps_default if (
+                max_sweeps is None) else max_sweeps  # useful on F7
         self._dimension_offset = 0
         '''budget = (dimension + offset) * budget_multiplier'''
         self._data = _collections.OrderedDict()
@@ -848,7 +862,7 @@ class ExperimentRepeater:
         it cannot account for problems that have not yet been run once.
 
         Calling ``done()`` increments the sweep counter iff it returns
-        `False`, the default for ``max_sweeps`` is ``1e4``. The attribute
+        `False`, the default for ``max_sweeps`` is ``20``. The attribute
         can be directly reassigned at any time.
 
         See also: `remaining_problems`
@@ -861,11 +875,11 @@ class ExperimentRepeater:
             return True
         if message:  # prints nothing when no data are found
             print(self.message_sweep(), end='')  # indicates "sequence of problems" case
-        self._sweeps += 1  # the sweep number to come
-        done = self._sweeps >= self.max_sweeps or (
+        self._sweeps += 1  # the sweep number to come, needed in remaining_problems()
+        done = self._sweeps > self.max_sweeps or (
                 self._sweeps > 1 and len(self._data) == 0) or (
                 self.n_problem_instances() > 0 and not self.remaining_problems())
-        self._sweeps -= done  # don't increment when done
+        self._sweeps -= done  # revert increment when done is True
         return done
     def remaining_problems(self, suite=None):
         """return `list` of (probably) remaining problem instances to run.