IPOP and BIPOP restart mechanisms

doc/optimizers.md

@@ -86,7 +86,9 @@ approxOptimizer.Optimize(f, coordinates);
 
 #### See also:
 
+ * [BIPOP_CMAES](#bipopcmaes)
  * [CMAES](#cmaes)
+ * [IPOP_CMAES](#ipopcmaes)
  * [Improving Evolution Strategies through Active Covariance Matrix Adaptation](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.114.4239&rep=rep1&type=pdfn)
  * [Evolution strategy in Wikipedia](https://en.wikipedia.org/wiki/Evolution_strategy)
 
@@ -778,6 +780,72 @@ optimizer2.Optimize(f, coordinates);
  * [SGD in Wikipedia](https://en.wikipedia.org/wiki/Stochastic_gradient_descent)
  * [SGD](#standard-sgd)
 
+## BIPOP_CMAES
+
+*An optimizer for [separable functions](#separable-functions).*
+
+BIPOP CMA-ES (Bi-Population CMA-ES) extends the idea of IPOP CMA-ES by using
+two intertwined restart strategies: one with an increasing population size and
+another maintaining a smaller, variable population size. This strategy allows
+BIPOP CMA-ES to adaptively balance exploration and exploitation across the
+fitness landscape, and can outperform IPOP. The larger population restarts aim
+to explore broadly, improving global search capabilities, while the smaller
+populations intensify the search in promising regions.
+
+### Constructors
+
+* `BIPOP_CMAES<`_`SelectionPolicyType, TransformationPolicyType`_`>()`
+* `BIPOP_CMAES<`_`SelectionPolicyType, TransformationPolicyType`_`>(`_`lambda, transformationPolicy`_`)`
+* `BIPOP_CMAES<`_`SelectionPolicyType, TransformationPolicyType`_`>(`_`lambda, transformationPolicy, batchSize`_`)`
+* `BIPOP_CMAES<`_`SelectionPolicyType, TransformationPolicyType`_`>(`_`lambda, transformationPolicy, batchSize, maxIterations, tolerance, selectionPolicy`_`)`
+* `BIPOP_CMAES<`_`SelectionPolicyType, TransformationPolicyType`_`>(`_`lambda, transformationPolicy, batchSize, maxIterations, tolerance, selectionPolicy, stepSize`_`)`
+* `BIPOP_CMAES<`_`SelectionPolicyType, TransformationPolicyType`_`>(`_`lambda, transformationPolicy, batchSize, maxIterations, tolerance, selectionPolicy, stepSize, maxRestarts`_`)`
+* `BIPOP_CMAES<`_`SelectionPolicyType, TransformationPolicyType`_`>(`_`lambda, transformationPolicy, batchSize, maxIterations, tolerance, selectionPolicy, stepSize, maxRestarts, populationFactor`_`)`
+* `BIPOP_CMAES<`_`SelectionPolicyType, TransformationPolicyType`_`>(`_`lambda, transformationPolicy, batchSize, maxIterations, tolerance, selectionPolicy, stepSize, maxRestarts, populationFactor, maxFunctionEvaluations`_`)`
+
+### Attributes
+
+| **type** | **name** | **description** | **default** |
+|----------|----------|-----------------|-------------|
+| `size_t` | **`lambda`** | The population size (0 uses a default size). | `0` |
+| `TransformationPolicyType` | **`transformationPolicy`** | Instantiated transformation policy used to map the coordinates to the desired domain. | `TransformationPolicyType()` |
+| `size_t` | **`batchSize`** | Batch size to use for the objective calculation. | `32` |
+| `size_t` | **`maxIterations`** | Maximum number of iterations. | `1000` |
+| `double` | **`tolerance`** | Maximum absolute tolerance to terminate the algorithm. | `1e-5` |
+| `SelectionPolicyType` | **`selectionPolicy`** | Instantiated selection policy used to calculate the objective. | `SelectionPolicyType()` |
+| `double` | **`stepSize`** | Initial step size. | `0` |
+| `size_t` | **`maxRestarts`** | Maximum number of restarts. | `9` |
+| `double` | **`populationFactor`** | The factor by which the population increases after each restart. | `2.0` |
+| `size_t` | **`maxFunctionEvaluations`** | Maximum number of function evaluations. | `1e9` |
+
+The _`SelectionPolicyType`_ and _`TransformationPolicyType`_ template parameters are used to control how the selection of points and the transformation of the decision variables are handled during the optimization process. For more information, check the [CMAES](#cmaes) class. The `lambda`, `transformationPolicy`, `batchSize`, `maxIterations`, `tolerance`, `selectionPolicy`, and `stepSize` are all parameters that affect the underlying CMAES process.
+
+#### Examples:
+
+<details open>
+<summary>Click to collapse/expand example code.
+</summary>
+
+```c++
+RosenbrockFunction f;
+arma::mat coordinates = f.GetInitialPoint();
+
+// IPOP Active CMA-ES
+BoundaryBoxConstraint<> b(-1, 1);
+BIPOP_CMAES optimizer(0, b, 32, 200, 1e-4, 5, 2, 9, 1e4);
+Optimizer.Optimize(f, coordinates);
+```
+
+</details>
+
+#### See also:
+
+ * [CMAES](#cmaes)
+ * [ActiveCMAES](#activecmaes)
+ * [IPOP_CMAES](#ipopcmaes)
+ * [Benchmarking a BI-Population CMA-ES on the BBOB-2009 Function Testbed](https://dl.acm.org/doi/pdf/10.1145/1570256.1570333)
+ * [Evolution strategy in Wikipedia](https://en.wikipedia.org/wiki/Evolution_strategy)
+
 ## Coordinate Descent (CD)
 
 *An optimizer for [partially differentiable functions](#partially-differentiable-functions).*
@@ -938,6 +1006,9 @@ approxOptimizer.Optimize(f, coordinates);
 
 #### See also:
 
+ * [ActiveCMAES](#activecmaes)
+ * [BIPOP_CMAES](#bipopcmaes)
+ * [IPOP_CMAES](#ipopcmaes)
  * [Completely Derandomized Self-Adaptation in Evolution Strategies](http://www.cmap.polytechnique.fr/~nikolaus.hansen/cmaartic.pdf)
  * [CMA-ES in Wikipedia](https://en.wikipedia.org/wiki/CMA-ES)
  * [Evolution strategy in Wikipedia](https://en.wikipedia.org/wiki/Evolution_strategy)
@@ -1484,6 +1555,73 @@ optimizer.Optimize(f, coordinates);
  * [HOGWILD!: A Lock-Free Approach to Parallelizing Stochastic Gradient Descent](https://arxiv.org/abs/1106.5730)
  * [Sparse differentiable separable functions](#sparse-differentiable-separable-functions)
 
+## IPOP_CMAES
+
+*An optimizer for [separable functions](#separable-functions).*
+
+IPOP CMA-ES (Increasing Population Size CMA-ES) is an extension of the
+Covariance Matrix Adaptation Evolution Strategy (CMA-ES). It introduces a 
+restart mechanism that progressively increases the population size. This 
+approach is beneficial for optimizing multi-modal functions,
+characterized by numerous local optima. The restart mechanism is designed to 
+improve the adaptability of CMA-ES by improving the likelihood of escaping
+local optima, thus increasing the chances of discovering the global optimum.
+
+### Constructors
+
+* `IPOP_CMAES<`_`SelectionPolicyType, TransformationPolicyType`_`>()`
+* `IPOP_CMAES<`_`SelectionPolicyType, TransformationPolicyType`_`>(`_`lambda, transformationPolicy`_`)`
+* `IPOP_CMAES<`_`SelectionPolicyType, TransformationPolicyType`_`>(`_`lambda, transformationPolicy, batchSize`_`)`
+* `IPOP_CMAES<`_`SelectionPolicyType, TransformationPolicyType`_`>(`_`lambda, transformationPolicy, batchSize, maxIterations, tolerance, selectionPolicy`_`)`
+* `IPOP_CMAES<`_`SelectionPolicyType, TransformationPolicyType`_`>(`_`lambda, transformationPolicy, batchSize, maxIterations, tolerance, selectionPolicy, stepSize`_`)`
+* `IPOP_CMAES<`_`SelectionPolicyType, TransformationPolicyType`_`>(`_`lambda, transformationPolicy, batchSize, maxIterations, tolerance, selectionPolicy, stepSize, maxRestarts`_`)`
+* `IPOP_CMAES<`_`SelectionPolicyType, TransformationPolicyType`_`>(`_`lambda, transformationPolicy, batchSize, maxIterations, tolerance, selectionPolicy, stepSize, maxRestarts, populationFactor`_`)`
+* `IPOP_CMAES<`_`SelectionPolicyType, TransformationPolicyType`_`>(`_`lambda, transformationPolicy, batchSize, maxIterations, tolerance, selectionPolicy, stepSize, maxRestarts, populationFactor, maxFunctionEvaluations`_`)`
+
+### Attributes
+
+| **type** | **name** | **description** | **default** |
+|----------|----------|-----------------|-------------|
+| `size_t` | **`lambda`** | The population size (0 uses a default size). | `0` |
+| `TransformationPolicyType` | **`transformationPolicy`** | Instantiated transformation policy used to map the coordinates to the desired domain. | `TransformationPolicyType()` |
+| `size_t` | **`batchSize`** | Batch size to use for the objective calculation. | `32` |
+| `size_t` | **`maxIterations`** | Maximum number of iterations. | `1000` |
+| `double` | **`tolerance`** | Maximum absolute tolerance to terminate the algorithm. | `1e-5` |
+| `SelectionPolicyType` | **`selectionPolicy`** | Instantiated selection policy used to calculate the objective. | `SelectionPolicyType()` |
+| `double` | **`stepSize`** | Initial step size. | `0` |
+| `size_t` | **`maxRestarts`** | Maximum number of restarts. | `9` |
+| `double` | **`populationFactor`** | The factor by which the population increases after each restart. | `2.0` |
+| `size_t` | **`maxFunctionEvaluations`** | Maximum number of function evaluations. | `1e9` |
+
+The _`SelectionPolicyType`_ and _`TransformationPolicyType`_ template parameters are used to control how the selection of points and the transformation of the decision variables are handled during the optimization process. For more information, check the [CMAES](#cmaes) class. The `lambda`, `transformationPolicy`, `batchSize`, `maxIterations`, `tolerance`, `selectionPolicy`, and `stepSize` are all parameters that affect the underlying CMAES process.
+
+#### Examples:
+
+<details open>
+<summary>Click to collapse/expand example code.
+</summary>
+
+```c++
+RosenbrockFunction f;
+arma::mat coordinates = f.GetInitialPoint();
+
+// IPOP Active CMA-ES
+BoundaryBoxConstraint<> b(-1, 1);
+IPOP_CMAES optimizer(0, b, 32, 200, 1e-4, 5, 2, 9, 1e4);
+Optimizer.Optimize(f, coordinates);
+```
+
+</details>
+
+#### See also:
+
+ * [CMAES](#cmaes)
+ * [ActiveCMAES](#activecmaes)
+ * [BIPOP_CMAES](#bipopcmaes)
+ * [A Restart CMA Evolution Strategy With Increasing Population Size](http://www.cmap.polytechnique.fr/~nikolaus.hansen/cec2005ipopcmaes.pdf)
+ * [Evolution strategy in Wikipedia](https://en.wikipedia.org/wiki/Evolution_strategy)
+
+
 ## IQN
 
 *An optimizer for [differentiable separable functions](#differentiable-separable-functions).*

include/ensmallen.hpp

@@ -103,6 +103,7 @@
 #include "ensmallen_bits/bigbatch_sgd/bigbatch_sgd.hpp"
 #include "ensmallen_bits/cmaes/cmaes.hpp"
 #include "ensmallen_bits/cmaes/active_cmaes.hpp"
+#include "ensmallen_bits/cmaes/pop_cmaes.hpp"
 #include "ensmallen_bits/cd/cd.hpp"
 #include "ensmallen_bits/cne/cne.hpp"
 #include "ensmallen_bits/de/de.hpp"

include/ensmallen_bits/cmaes/cmaes.hpp

@@ -172,6 +172,15 @@ class CMAES
   double& StepSize()
   { return stepSize; }
 
+  //! Get the total number of function evaluations.
+  size_t FunctionEvaluations() const 
+  { return functionEvaluations; }
+
+  //! Type of Selection Policy.
+  typedef SelectionPolicyType selectionPolicyType;
+  //! Type of Transformation Policy.
+  typedef TransformationPolicyType transformationPolicyType;
+
  private:
   //! Population size.
   size_t lambda;
@@ -195,6 +204,9 @@ class CMAES
 
   //! The step size.
   double stepSize;
+
+  //! Counter for the number of function evaluations.
+  size_t functionEvaluations = 0;
 };
 
 /**

include/ensmallen_bits/cmaes/cmaes_impl.hpp

@@ -151,6 +151,7 @@ typename MatType::elem_type CMAES<SelectionPolicyType,
     terminate |= Callback::Evaluate(*this, function, transformedIterate,
         objective, callbacks...);
   }
+  functionEvaluations += numFunctions;
 
   ElemType overallObjective = currentObjective;
   ElemType lastObjective = std::numeric_limits<ElemType>::max();
@@ -235,6 +236,8 @@ typename MatType::elem_type CMAES<SelectionPolicyType,
         transformationPolicy.Transform(mPosition[idx1]), terminate,
         callbacks...);
 
+    functionEvaluations += lambda; 
+
     // Update best parameters.
     if (currentObjective < overallObjective)
     {

include/ensmallen_bits/cmaes/pop_cmaes.hpp

@@ -0,0 +1,175 @@
+/**
+ * @file ipop_cmaes_impl.hpp
+ * @author Marcus Edel
+ * @author Benjami Parellada
+ *
+ * Definition of the IPOP Covariance Matrix Adaptation Evolution Strategy
+ * as proposed by A. Auger and N. Hansen in "A Restart CMA Evolution
+ * Strategy With Increasing Population Size" and BIPOP Covariance Matrix
+ * Adaptation Evolution Strategy as proposed by N. Hansen in "Benchmarking 
+ * a BI-population CMA-ES on the BBOB-2009 function testbed".
+ *
+ * ensmallen is free software; you may redistribute it and/or modify it under
+ * the terms of the 3-clause BSD license.  You should have received a copy of
+ * the 3-clause BSD license along with ensmallen.  If not, see
+ * http://www.opensource.org/licenses/BSD-3-Clause for more information.
+ */
+#ifndef ENSMALLEN_CMAES_POP_CMAES_HPP
+#define ENSMALLEN_CMAES_POP_CMAES_HPP
+
+#include "cmaes.hpp"
+
+namespace ens {
+
+/**
+ * Population-based CMA-ES (POP-CMA-ES) that can operate as either IPOP-CMA-ES
+ * or BIPOP-CMA-ES based on a flag.
+ * 
+ * IPOP CMA-ES is a variant of the stochastic search algorithm
+ * CMA-ES - Covariance Matrix Adaptation Evolution Strategy.
+ * IPOP CMA-ES, also known as CMAES with increasing population size, 
+ * incorporates a restart strategy that involves gradually increasing
+ * the population size. This approach is specifically designed to 
+ * enhance the performance of CMA-ES on multi-modal functions.
+ *
+ * For more information, please refer to:
+ *
+ * @code
+ * @INPROCEEDINGS{1554902,
+ *   author={Auger, A. and Hansen, N.},
+ *   booktitle={2005 IEEE Congress on Evolutionary Computation},
+ *   title={A restart CMA evolution strategy with increasing population size},
+ *   year={2005},
+ *   volume={2},
+ *   number={},
+ *   pages={1769-1776 Vol. 2},
+ *   doi={10.1109/CEC.2005.1554902}}
+ * @endcode
+ * 
+ * IPOP CMA-ES can optimize separable functions.  For more details, see the
+ * documentation on function types included with this distribution or on the
+ * ensmallen website.
+ * 
+ * BI-Population CMA-ES is a variant of the stochastic search algorithm
+ * CMA-ES - Covariance Matrix Adaptation Evolution Strategy.
+ * It implements a dual restart strategy with varying population sizes: one 
+ * increasing and one with smaller, varied sizes. This BI-population approach
+ * is designed to optimize performance on multi-modal function testbeds by 
+ * leveraging different exploration and exploitation dynamics.
+ *
+ * For more information, please refer to:
+ *
+ * @code
+ * @inproceedings{hansen2009benchmarking,
+ *   title={Benchmarking a BI-population CMA-ES on the BBOB-2009 function testbed},
+ *   author={Hansen, Nikolaus},
+ *   booktitle={Proceedings of the 11th annual conference companion on genetic and evolutionary computation conference: late breaking papers},
+ *   pages={2389--2396},
+ *   year={2009}}
+ * @endcode
+ *
+ * BI-Population CMA-ES can efficiently handle separable, multimodal, and weak
+ * structure functions across various dimensions, as demonstrated in the 
+ * comprehensive results of the BBOB-2009 function testbed. The optimizer
+ * utilizes an interlaced multistart strategy to balance between broad 
+ * exploration and intensive exploitation, adjusting population sizes and 
+ * step-sizes dynamically.
+ */
+template<typename SelectionPolicyType = FullSelection,
+         typename TransformationPolicyType = EmptyTransformation<>,
+         bool UseBIPOPFlag = true>
+class POP_CMAES : public CMAES<SelectionPolicyType, TransformationPolicyType>
+{
+ public:
+  /**
+   * Construct the POP-CMA-ES optimizer with the given parameters.
+   * Other than the same CMA-ES parameters, it also adds the maximum number of 
+   * restarts, the increase in population factor, the maximum number of 
+   * evaluations, as well as a flag indicating to use BIPOP or not.
+   * The suggested values are not necessarily good for the given problem, so it
+   * is suggested that the values used be tailored to the task at hand. The
+   * maximum number of iterations refers to the maximum number of points that
+   * are processed (i.e., one iteration equals one point; one iteration does not
+   * equal one pass over the dataset).
+   * 
+   * @param lambda The initial population size (0 use the default size).
+   * @param transformationPolicy Instantiated transformation policy used to
+   *    map the coordinates to the desired domain.
+   * @param batchSize Batch size to use for the objective calculation.
+   * @param maxIterations Maximum number of iterations allowed.
+   * @param tolerance Maximum absolute tolerance to terminate algorithm.
+   * @param selectionPolicy Instantiated selection policy used to calculate the
+   *     objective.
+   * @param stepSize Starting sigma/step size (will be modified).
+   * @param populationFactor The factor by which population increases
+   *     after each restart.
+   * @param maxRestarts Maximum number of restarts.
+   * @param maxFunctionEvaluations Maximum number of function evaluations.
+   */
+  POP_CMAES(const size_t lambda = 0,
+           const TransformationPolicyType& transformationPolicy = 
+              TransformationPolicyType(),
+           const size_t batchSize = 32,
+           const size_t maxIterations = 1000,
+           const double tolerance = 1e-5,
+           const SelectionPolicyType& selectionPolicy = SelectionPolicyType(),
+           double stepSize = 0,
+           const double populationFactor = 2,
+           const size_t maxRestarts = 9,
+           const size_t maxFunctionEvaluations = 1e9);
+
+  /**
+   * Set POP-CMA-ES specific parameters.
+   */
+  template<typename SeparableFunctionType,
+           typename MatType,
+           typename... CallbackTypes>
+  typename MatType::elem_type Optimize(SeparableFunctionType& function,
+                                       MatType& iterate,
+                                       CallbackTypes&&... callbacks);
+
+  //! Get the population factor.
+  double PopulationFactor() const { return populationFactor; }
+  //! Modify the population factor.
+  double& PopulationFactor() { return populationFactor; }
+
+  //! Get the maximum number of restarts.
+  size_t MaxRestarts() const { return maxRestarts; }
+  //! Modify the maximum number of restarts.
+  size_t& MaxRestarts() { return maxRestarts; }
+
+  //! Get the maximum number of function evaluations.
+  size_t MaxFunctionEvaluations() const { return maxFunctionEvaluations; }
+  //! Modify the maximum number of function evaluations.
+  size_t& MaxFunctionEvaluations() { return maxFunctionEvaluations; }
+
+  //! Get the BIPOP mode flag.
+  static constexpr bool UseBIPOP() { return UseBIPOPFlag; }
+
+ private:
+  //! Population factor
+  double populationFactor;
+
+  //! Maximum number of restarts.
+  size_t maxRestarts;
+
+  //! Maximum number of function evaluations.
+  size_t maxFunctionEvaluations;
+
+};
+
+// Define IPOP_CMAES and BIPOP_CMAES using the POP_CMAES template
+template<typename SelectionPolicyType = FullSelection,
+         typename TransformationPolicyType = EmptyTransformation<>>
+using IPOP_CMAES = POP_CMAES<SelectionPolicyType, TransformationPolicyType, false>;
+
+template<typename SelectionPolicyType = FullSelection,
+         typename TransformationPolicyType = EmptyTransformation<>>
+using BIPOP_CMAES = POP_CMAES<SelectionPolicyType, TransformationPolicyType, true>;
+
+} // namespace ens
+
+// Include implementation.
+#include "pop_cmaes_impl.hpp"
+
+#endif