Introduce Policy Methods for MOEA/D-DE

HISTORY.md

@@ -27,13 +27,16 @@
 
  * Make Callback flexible for MultiObjective Optimizers
    ([#289](https://github.com/mlpack/ensmallen/pull/289)).
-   
+
  * Add ZDT Test Suite
    ([#273](https://github.com/mlpack/ensmallen/pull/273)).
 
  * Add MOEA-D/DE Optimizer
    ([#269](https://github.com/mlpack/ensmallen/pull/269)).
 
+ * Introduce Policy Methods for MOEA/D-DE
+   ([#293](https://github.com/mlpack/ensmallen/pull/293)).
+
 ### ensmallen 2.16.1: "Severely Dented Can Of Polyurethane"
 ###### 2021-03-02
  * Fix test compilation issue when `ENS_USE_OPENMP` is set

include/ensmallen_bits/moead/decomposition_policies/pbi_decomposition.hpp

@@ -0,0 +1,67 @@
+/**
+ * @file pbi_decomposition.hpp
+ * @author Nanubala Gnana Sai
+ *
+ * The Penalty Based Boundary Intersection(PBI) Decomposition policy.
+ *
+ * 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_MOEAD_PBI_HPP
+#define ENSMALLEN_MOEAD_PBI_HPP
+
+namespace ens {
+
+/**
+ * Penalty Based Boundary Intersection (PBI) method is a weight decomposition method,
+ * it tries to find the intersection between bottom-most boundary of the attainable
+ * objective set with the reference directions.
+ *
+ * The goal is to minimize the distance between objective vectors with the ideal point
+ * along the reference direction. To handle equality constraints, a penalty parameter
+ * theta is used.
+ *
+ * For more information, see the following:
+ * @code
+ * article{zhang2007moea,
+ * title={MOEA/D: A multiobjective evolutionary algorithm based on decomposition},
+ * author={Zhang, Qingfu and Li, Hui},
+ * journal={IEEE Transactions on evolutionary computation},
+ * pages={712--731},
+ * year={2007}
+ * @endcode
+ */
+class PenaltyBoundaryIntersection
+{
+ public:
+  PenaltyBoundaryIntersection(const double theta = 5) :
+      theta(theta)
+  {
+    /* Nothing to do. */
+  }
+
+  template<typename VecType>
+  typename VecType::elem_type Apply(const VecType& weight,
+                                    const VecType& idealPoint,
+                                    const VecType& candidateFitness)
+  {
+    typedef typename VecType::elem_type ElemType;
+    //! A unit vector in the same direction as the provided weight vector.
+    const VecType referenceDirection = weight / arma::norm(weight, 1);
+    //! Distance of F(x) from the idealPoint along the reference direction.
+    const ElemType d1 = arma::dot(candidateFitness - idealPoint, referenceDirection);
+    //! Length of projection line of F(x) on the reference direction.
+    const ElemType d2 = arma::norm(candidateFitness - (idealPoint + d1 * referenceDirection), 1);
+
+    return d1 + static_cast<ElemType>(theta) * d2;
+  }
+
+  private:
+    double theta;
+};
+
+} // namespace ens
+
+#endif

include/ensmallen_bits/moead/decomposition_policies/tchebycheff_decomposition.hpp

@@ -0,0 +1,55 @@
+/**
+ * @file tchebycheff_decomposition.hpp
+ * @author Nanubala Gnana Sai
+ *
+ * The Tchebycheff Weight Decomposition policy.
+ *
+ * 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_MOEAD_TCHEBYCHEFF_HPP
+#define ENSMALLEN_MOEAD_TCHEBYCHEFF_HPP
+
+namespace ens {
+
+/**
+ * The Tchebycheff method works by taking the maximum of element-wise product
+ * between reference direction and the line connecting objective vector and
+ * ideal point.
+ *
+ * Under mild conditions, for each Pareto Optimal point there exists a reference
+ * direction such that the given point is also the optimal solution
+ * to this scalar objective.
+ *
+ * For more information, see the following:
+ * @code
+ * article{zhang2007moea,
+ * title={MOEA/D: A multiobjective evolutionary algorithm based on decomposition},
+ * author={Zhang, Qingfu and Li, Hui},
+ * journal={IEEE Transactions on evolutionary computation},
+ * pages={712--731},
+ * year={2007}
+ * @endcode
+ */
+class Tchebycheff
+{
+ public:
+  Tchebycheff()
+  {
+    /* Nothing to do. */
+  }
+
+  template<typename VecType>
+  typename VecType::elem_type Apply(const VecType& weight,
+                                    const VecType& idealPoint,
+                                    const VecType& candidateFitness)
+  {
+    return arma::max(weight % arma::abs(candidateFitness - idealPoint));
+  }
+};
+
+} // namespace ens
+
+#endif

include/ensmallen_bits/moead/decomposition_policies/weighted_decomposition.hpp

@@ -0,0 +1,51 @@
+/**
+ * @file weighted_decomposition.hpp
+ * @author Nanubala Gnana Sai
+ *
+ * The Weighted Average Decomposition policy.
+ *
+ * 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_MOEAD_WEIGHTED_HPP
+#define ENSMALLEN_MOEAD_WEIGHTED_HPP
+
+namespace ens {
+
+/**
+ * The Weighted average method of decomposition. The working principle is to
+ * minimize the dot product between reference direction and the line connecting
+ * objective vector and ideal point.
+ *
+ * For more information, see the following:
+ * @code
+ * article{zhang2007moea,
+ * title={MOEA/D: A multiobjective evolutionary algorithm based on decomposition},
+ * author={Zhang, Qingfu and Li, Hui},
+ * journal={IEEE Transactions on evolutionary computation},
+ * pages={712--731},
+ * year={2007}
+ * @endcode
+ */
+class WeightedAverage
+{
+ public:
+  WeightedAverage()
+  {
+    /* Nothing to do. */
+  }
+
+  template<typename VecType>
+  typename VecType::elem_type Apply(const VecType& weight,
+                                    const VecType& /* idealPoint */,
+                                    const VecType& candidateFitness)
+  {
+    return arma::dot(weight, candidateFitness);
+  }
+};
+
+} // namespace ens
+
+#endif

include/ensmallen_bits/moead/moead.hpp

@@ -3,11 +3,9 @@
  * @author Utkarsh Rai
  * @author Nanubala Gnana Sai
  *
- * MOEA/D, Multi Objective Evolutionary Algorithm based on Decompositon is a
- * multi objective optimization algorithm. It employs evolutionary algorithms,
- * to find better solutions by iterating on the previous solutions and
- * decomposition approaches, to convert the multi objective problem to a single
- * objective one, to find the best Pareto Front for the given problem.
+ * MOEA/D-DE is a multi objective optimization algorithm. MOEA/D-DE
+ * uses genetic algorithms along with a set of reference directions
+ * to drive the population towards the Optimal Front.
  *
  * 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
@@ -18,35 +16,38 @@
 #ifndef ENSMALLEN_MOEAD_MOEAD_HPP
 #define ENSMALLEN_MOEAD_MOEAD_HPP
 
+//! Decomposition policies.
+#include "decomposition_policies/tchebycheff_decomposition.hpp"
+#include "decomposition_policies/weighted_decomposition.hpp"
+#include "decomposition_policies/pbi_decomposition.hpp"
+
+//! Weight Init policies.
+#include "weight_init_policies/bbs_init.hpp"
 namespace ens {
 
 /**
- * This class implements the MOEA/D algorithm with Differential Evolution
- * crossover. Step numbers used in different parts of the implementation
- * correspond to the step number used in the original algorithm by the author.
+ * MOEA/D-DE (Multi Objective Evolutionary Algorithm based on Decompositon - 
+ * Differential Variant) is a multiobjective optimization algorithm. This class 
+ * implements the said optimizer. 
+ *
+ * The algorithm works by generating a candidate population from a fixed starting point. 
+ * Reference directions are generated to guide the optimization process towards the Pareto Front. 
+ * Further, a decomposition function is defined to decompose the problem to a scalar optimization 
+ * objective. Utilizing genetic operators, offsprings are generated with better decomposition values 
+ * to replace the neighboring parent solutions. 
  *
  * For more information, see the following:
  * @code
- * @article{article,
- * author = {Zhang, Qingfu and Li, Hui},
- * year = {2008},
- * pages = {712 - 731},
- * title = {MOEA/D: A Multiobjective Evolutionary Algorithm Based on
- *    Decomposition},
- * journal = {Evolutionary Computation, IEEE Transactions on},
- *
- * @article{4633340,
- * author={H. {Li} and Q. {Zhang}},
- * year={2009},
- * pages={284-302},}
- * title={Multiobjective Optimization Problems With Complicated Pareto Sets, MOEA/D and NSGA-II},
- * journal={IEEE Transactions on Evolutionary Computation},
+ * @article{li2008multiobjective,
+ * title={Multiobjective optimization problems with complicated Pareto sets, MOEA/D and NSGA-II},
+ * author={Li, Hui and Zhang, Qingfu},
+ * journal={IEEE transactions on evolutionary computation},
+ * pages={284--302},
+ * year={2008},
  * @endcode
- *
- * MOEA/D can optimize arbitrary multi-objective functions. For more details,
- * see the documentation on function types included with this distribution or
- * on the ensmallen website.
  */
+template<typename InitPolicyType = BayesianBootstrap,
+         typename DecompPolicyType = Tchebycheff>
 class MOEAD {
  public:
   /**
@@ -82,7 +83,9 @@ class MOEAD {
         const size_t maxReplace = 2,
         const double epsilon = 1E-10,
         const arma::vec& lowerBound = arma::zeros(1, 1),
-        const arma::vec& upperBound = arma::ones(1, 1));
+        const arma::vec& upperBound = arma::ones(1, 1),
+        const InitPolicyType initPolicy = InitPolicyType(),
+        const DecompPolicyType decompPolicy = DecompPolicyType());
 
   /**
    * Constructor for the MOEA/D optimizer. This constructor is provides an
@@ -119,7 +122,9 @@ class MOEAD {
           const size_t maxReplace = 2,
           const double epsilon = 1E-10,
           const double lowerBound = 0,
-          const double upperBound = 1);
+          const double upperBound = 1,
+          const InitPolicyType initPolicy = InitPolicyType(),
+          const DecompPolicyType decompPolicy = DecompPolicyType());
 
   /**
    * Optimize a set of objectives. The initial population is generated
@@ -202,6 +207,15 @@ class MOEAD {
   //! `Optimize()` has been called.
   const arma::cube& ParetoFront() const { return paretoFront; }
 
+  //! Get the weight initialization policy.
+  const InitPolicyType& InitPolicy() const { return initPolicy; }
+  //! Modify the weight initialization policy.
+  InitPolicyType& InitPolicy() { return initPolicy; }
+
+  //! Get the weight decomposition policy.
+  const DecompPolicyType& DecompPolicy() const { return decompPolicy; }
+  //! Modify the weight decomposition policy.
+  DecompPolicyType& DecompPolicy() { return decompPolicy; }
 
  private:
   /**
@@ -212,8 +226,8 @@ class MOEAD {
    * @return std::tuple<size_t, size_t> The chosen pair of indices.
    */
   std::tuple<size_t, size_t> Mating(size_t subProblemIdx,
-                                     const arma::umat& neighborSize,
-                                     bool sampleNeighbor);
+                                    const arma::umat& neighborSize,
+                                    bool sampleNeighbor);
 
   /**
    * Mutate the child formed by the crossover of two random members of the
@@ -232,19 +246,6 @@ class MOEAD {
               const MatType& lowerBound,
               const MatType& upperBound);
 
-  /**
-   * Decompose the multi objective problem to a single objective problem.
-   *
-   * @param subProblemWeight The Decomposition weight vector of the current subproblem.
-   * @param idealPoint The reference point z for a decomposition problem.
-   * @param candidateFitness The fitness value of the candidate.
-   * @return The real value obtained from the decomposed function.
-   */
-  template<typename ElemType>
-  ElemType DecomposeObjectives(const arma::Col<ElemType>& subProblemWeight,
-                               const arma::Col<ElemType>& idealPoint,
-                               const arma::Col<ElemType>& candidateFitness);
-
   /**
    * Evaluate objectives for the elite population.
    *
@@ -316,6 +317,12 @@ class MOEAD {
   //! The set of all the Pareto optimal objective vectors.
   //! Stored after Optimize() is called.
   arma::cube paretoFront;
+
+  //! Policy to initialize the reference directions (weights) matrix.
+  InitPolicyType initPolicy;
+
+  //! Policy to decompose the weights.
+  DecompPolicyType decompPolicy;
 };
 
 } // namespace ens