Reference Set Generator: A Method for Pareto Front Approximation and Reference Set Generation

Abstract

In this paper, we address the problem of obtaining bias-free and complete finite size approximations of the solution sets (Pareto fronts) of multi-objective optimization problems (MOPs). Such approximations are, in particular, required for the fair usage of distance-based performance indicators, which are frequently used in evolutionary multi-objective optimization (EMO). If the Pareto front approximations are biased or incomplete, the use of these performance indicators can lead to misleading or false information. To address this issue, we propose the Reference Set Generator (RSG), which can, in principle, be applied to Pareto fronts of any shape and dimension. We finally demonstrate the strength of the novel approach on several benchmark problems.

1. Introduction

Multi-objective optimization has become an integral part of the decision making for many real-world problems. In a multi-objective optimization problem (MOP), one is faced with the issue of concurrently optimizing k individual objectives. The set of optimal solutions is called the Pareto set, and its image is the Pareto front. The latter set is, in many cases, most important for the decision maker (DM), since it provides him/her with an overview of the optimal performances for his/her project. What makes MOPs hard to deal with is that one can expect that both the Pareto set and front form—at least locally and under certain assumptions on the model—objects of dimension $k-1$ [1]. For the numerical treatment of MOPs, specialized evolutionary algorithms, called multi-objective evolutionary algorithms (MOEAs), have caught the interest of many researchers and practitioners during the last three decades [2]. MOEAs are population-based and hence allow one to obtain a finite approximation of the entire solution set in one run of the algorithm. For the performance assessment of the outcome sets, several different indicators have been proposed so far (e.g., [3,4,5,6,7,8]). Some of these performance indicators are distance-based and require a “suitable” finite-size representation of the Pareto front. While until now, a vast variety of different MOEAs have been proposed and analyzed, it is fair to say that the generation of suitable reference sets has played a rather minor role in the evolutionary multi-objective optimization (EMO) community. It is evident that such reference sets should be complete. Furthermore, as we show in this work, a biased representation can lead to misleading or even false information.

To fill this gap, we propose in this work the Reference Set Generator (RSG). The main steps of RSG are as follows: (i) A first approximation $A_y$ of the Pareto front is either taken or generated. This set can be, in principle, of arbitrary size, and the elements can be non-uniformly distributed along the Pareto front (i.e., biased). However, all of these elements have to be “close enough” to the set of interest. In order to obtain a bias-free approximation, (ii) component detection and (iii) a filling step are applied to $A_y$. Finally, (iv) a reduction step is applied. The RSG is applicable to MOPs with Pareto fronts of, in principle, any shape and dimension. This is in contrast to existing methods that generate such reference sets that require an analytic expression of either the Pareto front or the Pareto set (or a tight superset of it). Furthermore, the resulting reference set is of any desired magnitude. We will show the strength of the novel method on several benchmark problems.

The remainder of this paper is organized as follows: in Section 2, we briefly recall the background for the understanding of this work. We further discuss the related work and the performance indicators that benefit from our approach. In Section 3, we motivate the need for bias-free complete finite-size Pareto front approximations. In Section 4, we propose the Reference Set Generator (RSG) that aims for such sets. In Section 5, we present some numerical results on selected benchmark problems and compare the RSG to related algorithms. Finally, we draw our conclusions in Section 6 and give possible paths for future research.

2. Background and Related Work

We consider multi-objective optimization problems (MOPs) that can be mathematically expressed via

$$\underset{x\in Q}{min}F\left(x\right).$$

(MOP)

Hereby, the map F is defined as

$$F:Q\to {\mathbb{R}}^k, F\left(x\right)={(f_1\left(x\right),\dots ,f_k\left(x\right))}^T,$$

(1)

where we assume each of the individual objectives, $f_i:Q\to \mathbb{R}$, $i=1\dots ,k$, to be continuous. We stress, however, that the method we propose in the sequel, RSG, can, in principle, also be applied to discrete problems. Q is the domain of the objective functions that is typically expressed by equality and inequality constraints.

In order to define the optimality of a MOP, one can use the concept of dominance [9].

Definition 1. 

(a) 

Let $v,w\in {\mathbb{R}}^k$. Then, the vector v is less than w ($v{<}_{p}w$) if $v_i<w_i$ for all $i\in \{1,\dots ,k\}$. The relation ${\le }_p$ is defined analogously.

(b) 

$y\in Q$ is dominated by a point $x\in Q$ ($x\prec y$) with respect to (Equation (MOP)) if $F\left(x\right){\le }_{p}F\left(y\right)$ and $F\left(x\right)\ne F\left(y\right)$.

(c) 

$x\in Q$ is called a Pareto point or Pareto optimal if there is no $y\in Q$ that dominates x.

(d) 

The set $P_Q$ of Pareto optimal solutions

$$P_Q:=\{x\in Q:\nexists y\in Qs.t.y\prec x\}$$

(2)

is called the Pareto set.

(e) 

The image $F\left(P_Q\right)$ of the Pareto set is called the Pareto front.

One can expect that both the Pareto set and the Pareto front form, under certain conditions and at least locally, objects of dimension $k-1$. For details, we refer to [1]. Due to this “curse of dimensionality”, it is, hence, not possible for an evolutionary multi-objective optimization algorithm (MOEA) to keep all promising candidate solutions (e.g., all non-dominated ones) during the algorithm run. It is hence inevitable—at least for continuous problems—to select which of the promising solutions should be kept in order to obtain a “suitable” approximation of the solution set (in most cases, the Pareto front of the given MOP). Within MOEAs, this process is termed “selection”. Another term, which can be used synonymously, is “archiving”. The latter is typically used when the MOEA is equipped with an external archive.

Most of the existing MOEAs can be divided into three main classes: First, there exist MOEAs that are based on the concept of dominance (e.g., [10,11,12,13]). Second, there exist MOEAs that are based on decompositions (e.g., [14,15,16,17,18]), and third, there are MOEAs that make use of an indicator function (e.g., [19,20,21]). The selection strategies of the first generation of MOEAs of the first class are based on a combination of non-dominated sorting and niching (e.g., [22,23,24]). Later, elite preservation was included, leading to increased overall performance (and, as a consequence, better Pareto front approximations). This holds, e.g., for SPEA [25], PAES [13], SPEA-II [11], and NSGA-II [10]. Theoretical studies on selection mechanisms have been done by the groups of Rudolph [26,27,28,29] and Hanne [30,31,32,33]. All of these selection mechanisms deal with the abilities of the populations to reach the Pareto set/front. On the other hand, the distributions of the individuals along the Pareto sets/fronts have not been considered. The selection mechanisms of the MOEAs within the second and third class follow directly from the construction of the algorithms: selection in a decomposition-based MOEA is done by considering the values of the chosen scalarization functions. Analogously, the selection in an indicator-based MOEA is done by considering the indicator contributions.

Existing (external) archiving strategies can also be divided into three classes: (a) unbounded archivers, (b) implicitly bounded archivers, and (c) bounded archivers. Unbounded archivers store all promising solutions during the algorithm run. The magnitudes of such archives can exceed any given threshold if the algorithm is run long enough. Unbounded archivers have, e.g., been used and analyzed in [34,35,36,37,38,39,40]. $ϵ$-dominance [41] can be viewed as a weaker concept of dominance. This relation allows single solutions to “cover” entire parts of the Pareto front of a given MOP, which is the basis for most implicitly bounded archivers. Such strategies have first been considered in the context of evolutionary multi-objective optimization (EMO) by Laumanns et al. [42]. Later works proposed and analyzed different approximations (such as gap-free approximations of the Pareto front) and dealt with different sets of interest (e.g., the consideration of all nearly optimal or all $ϵ$-locally optimal solutions) [38,39,43]. Finally, bounded archivers have, e.g., been proposed in [44,45], where adaptive grid selections have been utilized. Bounded archivers tailored to the use of the hypervolume indicator have been suggested in [46,47]. In ref. [48], a bounded archiver aiming for Hausdorff approximations of the Pareto front is presented and analyzed. Laumanns and Zenklusen have proposed two bounded archivers that aim for $ϵ$-approximations of the Pareto front [49].

All of the selection/archiving strategies mentioned above have in common that they aim for a “best approximation” of the Pareto front out of the given (finite) data. A related but slightly different problem is to generate a “suitable” (in particular, complete and bias-free) finite-size approximation of the set of interest S for the sake of comparisons, even if S is known approximately or even analytically but is not “trivial” (e.g., a line segment, a simplex, or perfectly spherical). It is known that most selection mechanisms have a non-monotonic behavior, which may result in the fact that entire regions of the Pareto front are not covered. Some of the external archives have monotonic behavior and even aim for gap-free approximations. On the other hand, uniformity of the final archive cannot be guaranteed. Both issues are, e.g., discussed in [43]. The evolutionary multi-objective optimization platform PlatEMO [50] provides reference sets for many benchmark problems. The underyling method was proposed in Tian et al. It uses uniform sampling on the simplex and then maps these points to the particular Pareto fronts of each problem. However, an analytical expression or characterization of the Pareto front is required, and in some cases, the obtained set is not completely uniform. Furthermore, in pymoo [51]—a multi-objective optimization framework in Python—built-in functions to obtain reference sets of the Pareto fronts for selected MOPs are provided. This is mainly the case for problems where the fronts are given analytically. Some other reference sets are provided with fixed magnitude; however, no direct information is provided as to how they have been obtained. A method related to RSG can be found in [52], which has the aim of guiding the iterates of a particular Newton method toward the Pareto front. In this work, we extend this idea for the purpose of generating complete and bias-free Pareto front approximations of relatively large magnitudes (in particular, compared to population sizes used in EMO). RSG is, in principle, applicable to Pareto fronts of any shape or dimension. For this, however, an initial reference set has to be given. The retrieval of this set is problem-dependent, and it is not always clear how to obtain a suitable approximation (though we give some guidelines as to which method may be most promising for a given MOP).

Finally, reference sets such as the ones generated by RSG are helpful for the evaluation of the performance qualities of candidate sets (populations) in EMO. More precisely, such sets are required for all distance-based indicators. The earliest of such indicators are the Generational Distance (GD, [3]) and the Inverted Generational Distance. (IGD, [5]). Later, the indicator ${\mathsf{\Delta }}_p$ [6] was proposed, which is a combination of slight variants of the GD and IGD and can be viewed as an averaged version of the Hausdorff distance $d_H$. So far, there exist several extensions of these performance indicators. For instance, the consideration of continuous sets—either only the Pareto front or also the candidate solution set—has been done in [8,53], leading to modifications of $IGD$ and ${\mathsf{\Delta }}_p$. The indicators IGD+ [7] and DOA [54] are modifications of the IGD that are Pareto-compliant.

3. Motivation

Here, we motivate the need for complete and bias-free finite-size Pareto front approximations and propose the Reference Set Generator (RSG) that targets such sets in the next section.

Distance-based indicators require a “suitable” finite-size approximation of the Pareto front in order to give a “correct” value for the approximation quality of the considered candidate solution set. In particular, this holds for the abovementioned indicators GD, IGD, and ${\mathsf{\Delta }}_p$, together with their variants. Such representations are ideally uniformly spread along the entire Pareto front [53]. This, however, is a non-trivial task, unless the Pareto front is given analytically and has a relatively simple form (e.g., linear or perfectly spherical). Regrettably, this is the case for only a few test problems (e.g., DTLZ1 and DTLZ2). On the other hand, there exist quite a few benchmark MOPs where the shape of the Pareto set is relatively simple. For such problems, it is tempting to choose uniform samples from the Pareto set (i.e., $X=\{s_1,\dots ,s_m\}$, where all $s_i\in P_Q$) and to use the respective image $Y=F\left(X\right)$ to represent of the Pareto front. The following discussion shows, however, that this approach has to be handled with care, since it can induce unwanted biases in the approximations that, in turn, may result in misleading indicator values.

As the first example, consider the one-dimensional bi-objective problem

$$F\left(x\right)=\left(\begin{array}{c}1-{\displaystyle \frac{1}{x}}\\ {\displaystyle \frac{1}{x}}\end{array}\right).$$

(3)

Let the domain be given by $Q=[0.1,3]$; then, the Pareto set is identical to Q, and the Pareto front is the line segment that connects the points $a={(-9,10)}^{\top }$ and $b={(2/3,1/3)}^{\top }$. Figure 1 shows the result when using N equally spaced points along the Pareto set. As can be seen for $N=50$ and $N=500$, there is a clear bias of the images toward the right lower end of the Pareto front. For $N=10,000$, the Pareto front approximation is “complete” (at least from the practical point of view) and appears to be perfect. However, it possesses the same bias. To see the impact of the reference set on the performance indicators, consider the two hypothetical outcomes (e.g., possible results from different MOP solvers):

$$\begin{array}{cc}\hfill A& :=\left\{a+{\displaystyle \frac{2i-1}{10}}(b-a)|i\in \{1,\dots ,5\}\right\},\mathrm{and}\hfill \\ \hfill B& :=\left\{a+{\displaystyle \frac{i}{10}}(b-a)|i\in \{6,\dots ,10\}\right\}.\hfill \end{array}$$

(4)

Figure 2 shows the two sets together with the Pareto front. Note that A is the perfect five-element approximation of the Pareto front: the elements are equally distributed along the Pareto front, and the extreme points are shifted “halfway in” [53]. The set B is certainly not perfect, as it, e.g., fails to “cover” more than half of the front.

Table 1. Indicator values $I(O,R)$ for different indicators, the outcomes $O\in \{A,B\}$, and the representations $R\in \{R_{100}^x,R_{100}^y,R_{10,000}^x,R_{10,000}^y\}$ of the Pareto front. Better indicator values are diplayed in bold font.

	${\mathit{GD}}_1$	${\mathit{GD}}_2$	${\mathit{IGD}}_1$	${\mathit{IGD}}_2$	$\mathit{IGD}+$	${\mathsf{\Delta }}_1$	${\mathsf{\Delta }}_2$	${\mathsf{\Delta }}_{\mathbf{\infty }}$
$I(A,R_{100}^x)$	0.5118	0.7384	0.9084	0.9873	0.6423	0.9084	0.9873	1.3671
$I(B,R_{100}^x)$	0.0698	0.1002	0.4522	1.0744	0.3198	0.4522	1.0744	8.2024
$I(A,R_{100}^y)$	0.0684	0.0684	0.6835	0.7883	0.4833	0.6835	0.7883	1.2987
$I(B,R_{100}^y)$	0.0684	0.0684	2.5974	3.6765	1.8367	2.5974	3.6765	8.1341
$I(A,R_{10,000}^x)$	0.0028	0.0032	0.8968	0.9776	0.6341	0.8968	0.9776	1.3671
$I(B,R_{10,000}^x)$	0.0008	0.0010	0.4117	0.8792	0.2911	0.4117	0.8792	8.2024
$I(A,R_{10,000}^y)$	0.0007	0.0007	0.6835	0.7893	0.4833	0.6835	0.7893	1.3664
$I(B,R_{10,000}^y)$	0.0007	0.0007	2.5974	3.6767	1.8367	2.5974	3.6767	8.2018

shows values $I(O,R)$ for different distance-based indicators, the outcomes $O\in \{A,B\}$, and different representations R of the Pareto front. For $R=R_{10,000}^x$ (the one shown in Figure 1c), all indicators—except $d_H={\mathsf{\Delta }}_{\infty }$—yield lower values for B than for A, indicating (erroneously) that B is better than A. This is not the case for $d_H$, since the Hausdorff distance is determined by the maximum of the considered distances and not by an average of those (however, $d_H$ has other disadvantages in the context of EMO in that it most prominently punishes single outliers [6]). The situation changes when selecting $R=R_{10,000}^y$ as a representation of the front. This representation also contains N = 10,000 elements, but these are chosen uniformly along the Pareto front. Now, there is a tie for the two GD variants, and for all other indicators, A leads to better values than B. These values are indeed very close to the “correct” values: all exact GD values are equal to zero, since A and B are contained in the Pareto front. In order to compute the exact IGD values, a particular integral has to be solved [53]. When using $R_{10,000}^y$ as representation, the computation of the IGD values can be interpreted as a Riemann sum with N = 10,000 equally sized sub-intervals leading to perfect solutions—at least from the practical point of view.

We repeat the process, but now using only $N=100$ elements for the representation (see Table 1). We can see the same trend, i.e., that B appears to be better for $R_{100}^x$, while A appears to be better when using $R_{100}^y$. Furthermore, we see that the indicator values for $R_{100}^y$ are already quite close to the exact values (i.e., when using $R_{10,000}^y$). While the proper choice of N may not be an issue for bi-objective problems ($k=2$), this may become important for a larger number of objectives due to the “curse of dimensionality”: at least for continuous problems, one can expect that the Pareto front forms under certain (mild) assumptions a manifold of dimension $k-1$ [1].

We next consider further test problems. Figure 3, Figure 4, Figure 5 and Figure 6 show the Pareto front approximations for the commonly used test problems DTLZ1, DTLZ2, ZDT1, and ZDT3, respectively, where the representation has been obtained via uniform sampling in the decision variable space along the Pareto set. In all cases, the Pareto front representations appear to be perfect for large enough values of N. However, certain biases can be observed for lower values of N. For all test problems, we selected two points out of the representation and show the distances to their nearest neighbors (denoted by $d(y,N{N}_y)$). These distances differ by one order of magnitude, which confirms that the solutions are not uniformly distributed along the fronts. Using such representations, the same issues can arise as the one discussed above.

To conclude, the suitable representation of the Pareto front of a given MOP is crucial when considering distance-based performance indicators that use an average of the distances considered. Such representations are ideally equally distributed over the front. If the representation contains a bias, this may result in misleading indicator values, leading, in turn, to a wrong evaluation of the obtained results. In particular, the approach to performing the sampling along the Pareto set is, though tempting, not appropriate for such indicator-based indicators. In the sequel, we will propose a method that aims to achieve uniform Pareto front representations.

4. Reference Set Generator (RSG)

In the following, we will present the RSG, which is a method that aims to generate complete and bias-free Pareto front approximations. We will first present the general idea of the method and further on discuss the steps in detail.

4.1. General Idea

We assume in the following that we are interested in a Pareto front approximation of size N for a given MOP. Furthermore, we assume that we are given a set $A_y$ of (in principle) arbitrary size ℓ of non-dominated, possibly non-uniformly distributed points that are “close enough” to the PF. The computation of $A_y$ is in general a non-trivial task. Below, we will discuss different strategies to obtain suitable approximations. Given these data, the Reference Set Generator (RSG) consists of three main steps: component detection, filling, and reduction. More precisely, given $A_y$ that may have imperfections or biases in the approximation, the idea is to fill the gaps between the points within each connected point of $A_y$. This leads to a more complete set F with a higher cardinality than $A_y$, which can then be reduced to obtain a uniform reference set of size N. Note that PFs can be disconnected, and if we simply fill the gaps in $A_y$, we may introduce points that do not belong to the PF (see Figure 7b for such an example). Therefore, component detection must be performed before applying the filling process to each detected component (Figure 7a).

The general procedure of the RSG is presented in Algorithm 1, and each of the main steps will be explained in the following subsections.

Figure 8, Figure 9, Figure 10, Figure 11, Figure 12 and Figure 13 show all the steps of RSG on the test problems ZDT3, DTLZ7, WFG2, CONV3, CONV3-4, and CONV4-2F (we will discuss these examples in more detail in Section 5).

Algorithm 1 Reference Set Generator (RSG)

Input:  Starting set $A_y$, filling size $N_f$, output size N. Output:  PF reference Z. 1: $C=\{C^1,\dots ,C^{nc}\}\leftarrow$ ComponentDetection($A_y$) 2: for $i=1,\dots ,nc$ do                             ▹ for each component 3:     $F^i\leftarrow$ Filling($C^i,\lceil {\displaystyle \frac{N_f·\left|C^i\right|}{|A_y|}}\rceil$) 4: end for 5: $F\leftarrow {\bigcup }_i{F}^i$ 6: $Z\leftarrow$ reduction($F,N$) 7: return  Z

4.2. Component Detection

Since the Pareto front might be disconnected, a component detection on $A_y$ is needed. We use DBSCAN [55] in objective space for this purpose for three main reasons: (i) the number of components does not need to be known a priori, (ii) the method detects outliers, and (iii) we have observed that a density-based approach works better than a distance-based one (e.g., k-means) for component detection. DBSCAN has two parameters: $minpts$ and r. The selection of these parameters is problem-dependent. Depending on the information available about the Pareto front, we suggest the following values:

• If it is known that the PF is connected, this step can simply be omitted. Note that the main application of RSG is in the approximation of Pareto fronts of known benchmark functions, where the shapes of the PFs are at least known roughly.
• If the range of the PF is roughly known or normalized and the PF is disconnected (or at least suspected to be), r can be set to 10% of the range and $minpts$ to 10% of $|A_y|$ when few components are expected. Alternatively, r can be set to a smaller value (e.g., 2–3%) and $minpts$ to 1–2% of $|A_y|$ when several components are anticipated.
• No information of the PF is known a priori. To make the component detection process “parameter-free”, we compute a small grid search to find the optimal values of $minpts$ and r based on the weakest link function defined in [56]. Based on our experiments, we suggest setting the parameter values to $minpts\in \{2,3\}$ and $r\in \{0.10\overline{d},0.11\overline{d},\dots ,0.15\overline{d}\}$ for bi-objective problems and to $minpts\in \{3,4\}$ and $r\in \{0.19\overline{d},0.20\overline{d},\dots ,0.23\overline{d}\}$ otherwise, where $\overline{d}={\displaystyle \frac{2}{\ell (\ell -1)}}{\sum }_{p_i\ne p_j}|p_i-p_j|$ is the average pairwise distance between all points $p_i\in A_y$ and $\ell =|A_y|$.

A summary of the component detection process is presented in Algorithm 2. r and $minpts$ have to be given as grid search ranges: $r\_interval$ and $minpts\_interval$ are the input variables containing the lower and upper bounds of the grid search for r and $minpts$, respectively. The step size for r is also needed, and it is given in the input variable $r\_step$. For $minpts$, it is not needed, as this variable is an integer. With these values, the grid search values are defined as $minpts\in \{minpts\_min,minpts\_min+1,\dots ,minpts\_max\}$ and $r\in \{r\_min,r\_min+r\_step,r\_min+2r\_step,\dots ,r\_max\}$. If the grid search is not needed, simply set $r\_interval$ as $[r,r]$ and $minpts\_interval$ as $[minpts,minpts]$, using the desired values for r and $minpts$, and the component detection will be performed only once with those values. In the following, we describe the remaining steps for a single connected component. If multiple components exist, the procedures must be repeated analogously for each component $C^i$ identified by Algorithm 2.

Algorithm 2 Component Detection

Input:  starting set $A_y=\{p_1,\dots ,p_{\ell }\}$, number of objectives k, range of r used for the grid search $r\_interval=[r\_min,r\_max]$, size of the step taken for r in the grid search $r\_step$, range of $minpts$ used for the grid search $minpts\_range=[minpts\_min,minpts\_max]$. Output:  Number of clusters $nc$, clusters $C=\{C^1,\dots ,C^{nc}\}$. 1: Set $wlmin\leftarrow \infty$ 2: for  $minpts\in \{minpts\_min,minpts\_min+1,\dots ,minpts\_max\}$  do 3:     for $r\in \{r\_min,r\_min+r\_step,r\_min+2r\_step,\dots ,r\_max\}$ do 4:         $C_t,n{c}_t\leftarrow$ DBSCAN($A_y,r,minpts$) 5:         $wl\leftarrow$ WeakestLink($C_t$) 6:         if $wl\le wlmin$ then 7:            $C\leftarrow C_t$ 8:            $nc\leftarrow n{c}_t$ 9:            $wlmin\leftarrow wl$ 10:         end if 11:     end for 12: end for 13: return  $C=\{C^1,\dots ,C^{nc}\},nc$

4.3. Filling

Even if we know the PS a priori, a uniform sampling of the PS will not result in a uniform sampling of the PF. We assume that we have a set of points $A_y$ that is not uniformly distributed. However, if we fill the gaps and select N points from the filled set, we can obtain a more uniform set, leading to better IGD approximations when selecting points from these filled sets. The idea behind the filling step is to create a set that is as uniform as possible so that the reduction step (in particular, k-means) does not become stuck in non-uniform local optima, which would lead to non-uniform final sets. The next task is, therefore, to compute $N_f$ solutions that are ideally uniformly distributed along $A_y$.

This process is performed differently for $k=2$ and $k\ge 3$ objectives:

• For $k=2$, we sort the points of $A_y=\{p_1,\dots ,p_{\ell }\}$ in increasing order of $f_1$, i.e., the first objective. Then, we consider the piecewise linear curve formed by the segments between $p_1$ and $p_2$, $p_2$ and $p_3$, and so on. The total length of this curve is given by $\left|L\right|={\sum }_{i=1}^{\ell -1}\left|L_i\right|$, where $|L_i|=\parallel p_i-p_{i+1}{\parallel }_2$. To perform the filling, we arrange the $N_f$ desired points along the curve L such that the first point is $p_1$ and the subsequent points are distributed equidistantly along L. This is achieved by placing each point at a distance of ${\delta }_{\ell }=\left|L\right|/(N_f-1)$ from the previous one along L. See Algorithm 3 for details.
• The filling process for $k\ge 3$ consists of several intermediate steps that must be described first; see Algorithm 4 for a general outline of the procedure. The procedure is as follows: First, to better represent $A_y$ (particularly for the filling step), we triangulate this set in $k-1$ dimensional space. This is done because the PF for continuous MOPs forms a set whose dimension is at most $k-1$. To achieve this, we compute a “normal vector” $\eta$ to $A_y$ using Equation (8), and then we project it onto the $k-1$ hyperplane normal to $\eta$, obtaining the projected set $P_{k-1}$. After this, we compute the Delaunay triangulation [57] of $P_{k-1}$, which provides a triangulation $T^{\prime }$ that can be used in the original k-dimensional space. For some PFs, the triangulation may include triangles (or simplex for $k>3$) that extend beyond $A_y$ (Figure 12d), so a removal strategy is applied to eliminate these triangles and obtain the final triangulation T. Finally, each triangle $t_i\in T$ is uniformly filled at random with a number of points proportional to its area (or volume for $k>3$), resulting in the filled set F of size $N_f$.
  We will now describe each step in more detail in the following:

  -

  Computing “normal vector” $\left(\eta \right)$: Since the front is not known, we compute the normal direction $\eta$ orthogonal to the convex hull defined by the minimal elements of $A_y$. More precisely, we compute $\eta$ as follows: if $A_y=\{p_1,\dots ,p_{\ell }\}$, choose

  $$y_{\left(i\right)}^m\in arg\underset{j=1,\dots ,N^{\prime }}{min}{p}_{j,i},i=1,\dots ,k,$$

  (5)

  where $p_{j,i}$ denotes the i-th element of $p_j$, and set

  $$M:=(y_{\left(2\right)}^m-y_{\left(1\right)}^m,y_{\left(3\right)}^m-y_{\left(1\right)}^m,\dots ,y_{\left(k\right)}^m-y_{\left(1\right)}^m)\in {\mathbb{R}}^{k\times (k-1)}.$$

  (6)

  Next, compute a QR factorization of M, i.e.,

  $$M=QR=(q_1,\dots ,q_k)R,$$

  (7)

  where $Q\in {\mathbb{R}}^{k\times k}$ is an orthogonal matrix with column vectors $q_i$, and $R\in {\mathbb{R}}^{k\times (k-1)}$ is a right upper triangular matrix. Then, the vector

  $$\eta =-\mathrm{sgn}\left(q_{k,1}\right){\displaystyle \frac{q_k}{\parallel q_k{\parallel }_2}}$$

  (8)

  is the desired shifting direction. Since Q is orthogonal, the vectors $v_1:=q_1,\dots ,v_{k-1}:=q_{k-1}$ form an orthonormal basis of the hyperplane that is orthogonal to $\eta$. That is, these vectors can be used for the construction of $P_{k-1}$.

  -

  $k-1$ Projection $\left(P_{k-1}\right)$: We use $\eta$ as the first axis of a new coordinate system $(\eta ,v_1,\dots ,v_{k-1})$, where the vectors $v_i$ are defined as above. In this coordinate system, the orthonormal vectors $v_1,\dots ,v_{k-1}$ form the basis of a hyperplane orthogonal to $\eta$. $P_{k-1}$, and the projection of the points of $A_y$ onto this hyperplane is achieved by first expressing the points $p_i\in A_y$ in this new coordinate system as $p_i={\beta }^i\eta +{\beta }_1^i{v}_1+\dots +{\beta }_{k-1}^i{v}_{k-1}$ and then removing the first coordinate, yielding $p_i^{k-1}={\beta }_1^i{v}_1+\dots +{\beta }_{k-1}^i{v}_{k-1}$. Finally, $P_{k-1}=\{p_1^{k-1},\dots ,p_{\ell }^{k-1}\}$.

  -

  Delaunay Triangulation $\left(T^{\prime }\right)$: Compute the Delaunay triangulation of $P_{k-1}$. This returns $T^{\prime }$, which is a list of size ${\delta }^{\prime }$ containing the indices of $P_{k-1}$ that form the triangles (or simplices for $k>3$). The list $T^{\prime }$ serves as the triangulation for the k-dimensional set $A_y$, which is possible because $T^{\prime }$ consists of indices, making it independent of the dimension. We use ${\delta }^{\prime }$ to denote the number of triangles obtained, $\{T^{\prime }(i,1),\dots ,T^{\prime }(i,k)\}$ to denote the indices of the vertices forming triangle i, and $\{p_{T^{\prime }(i,1)},\dots ,p_{T^{\prime }(i,k)}\}$ to denote the corresponding vertices of triangle i.

  -

  Triangle Cleaning $\left(T\right)$: We identify three types of unwanted triangles: those with large sides, those with large areas, and those where the matrix containing the coordinates of the vertices has a large condition number. The type of cleaning applied depends on the problem; however, the procedure remains the same for any problematic triangle case and is outlined in Algorithm 5. First, the property ${\rho }_i$ (area, largest side, or condition number) is computed for all the triangles $i=1,\dots ,\delta$. Next, triangles i with ${\rho }_i>\tau$ are removed.

  -

  Triangle Filling $\left(F\right)$: For each triangle $t_i\in T$ with area $a_i$, we generate $\lceil {\displaystyle \frac{a_i}{A}}{N}_f\rceil$ points uniformly at random inside triangle $t_i$, following the procedure described in [58]. That is, the number of points is proportional to the area (or volume) of each triangle (or simplex). Here, $A={\sum }_{i=1}^{\delta }{a}_i$ is the total area of the triangulation.

Algorithm 3 Filling ($k=2$ Objectives)

Input:  starting set $A_y=\{p_1,\dots ,p_{\ell }\}$, filling size $N_f$ Output:  Filled set $F=\{y_1,\dots ,y_{N_f}\}$ 1: $X=\{x_1,\dots ,x_{\ell }\}\leftarrow$ sort $A_y$ according to its first objective $f_1$ 2: $L_i\leftarrow \parallel x_i-x_{i+1}\parallel \forall i=1,\dots ,\ell -1$ 3: $L\leftarrow {\sum }_{i=1}^{\ell -1}{L}_i$ 4: ${\delta }_{\ell }\leftarrow L/(N_f-1)$ 5: $dist\_left\leftarrow (0,0,\dots ,0)\in {\mathbb{R}}^{\ell }$ 6: for $i=1:\ell -1$ do                                                 ▹ compute number of points per segment 7:     $ratio\leftarrow \left(\right|L_i|+dist\_left\left(i\right))/{\delta }_{\ell }$ 8:     $points\_per\_segment\left(i\right)\leftarrow$$\lfloor ratio\rfloor$ 9:     $dist\_left(i+1)\leftarrow (ratio-\lfloor ratio\rfloor )·{\delta }_{\ell }$ 10: end for 11: $count=1$ 12: for $i=1:\ell -1$ do                                                                              ▹ for each line segment 13:     if $points\_per\_segment\left(i\right)>0$ then                          ▹ check if a point lands in segment $L_i$ 14:         ${\nu }_i:=(x_{i+1}-x_i)/L_i$ 15:         $y_{count}=x_i+({\delta }_{\ell }-dist\_left\left(i\right))·{\nu }_i$ 16:         $count\leftarrow count+1$ 17:         for $j=2:points\_per\_segment\left(i\right)$ do                          ▹ if $L_i$ has more than one point 18:            $y_{count}\leftarrow y_{count-1}+{\delta }_{\ell }·{\nu }_i$ 19:            $count\leftarrow count+1$ 20:         end for 21:     end if 22: end for 23: return  $F=\{y_1,\dots ,y_{N_f}\}$

Algorithm 4 Filling ($k\ge 3$ Objectives)

Input:  starting set $A_y=\{p_1,\dots ,p_{\ell }\}$, filling size $N_f$ Output:  Filled set $F=\{y_1,\dots ,y_{N_f}\}$ 1: $\eta \leftarrow$ normal_vector$\left(A_y\right)$ 2: $P_{k-1}\leftarrow$ projection$(A_y,\eta )$ 3: $T^{\prime }\leftarrow$ DelaunayTriangulation$\left(P_{k-1}\right)$ 4: $T\leftarrow$ TriangleCleaning$\left(T^{\prime }\right)$ 5: $F\leftarrow$ TriangleFilling$(T,A_y)$ 6: return  $F=\{y_1,\dots ,y_{N_f}\}$

Algorithm 5 Triangle Cleaning

Input:  starting set $A_y=\{p_1,\dots ,p_l\}$, triangulation $T^{\prime }\in {\mathbb{R}}^{k\times {\delta }^{\prime }}$, number of triangles ${\delta }^{\prime }$, parameter threshold $\tau$ Output:  cleaned triangulation T of size $\delta$ 1: if chosen property is area then 2:     ${\rho }_i\leftarrow {\displaystyle \frac{1}{k!}}det{\left[\right(\begin{array}{c}{p}_{T^{\prime }(i,2)}^T-p_{T^{\prime }(i,1)}^T\\ p_{T^{\prime }(i,3)}^T-p_{T^{\prime }(i,1)}^T\\ ⋮\\ p_{T^{\prime }(i,k)}^T-p_{T^{\prime }(i,1)}^T\end{array}\left){\left(\begin{array}{c}{p}_{T^{\prime }(i,2)}^T-p_{T^{\prime }(i,1)}^T\\ p_{T^{\prime }(i,3)}^T-p_{T^{\prime }(i,1)}^T\\ ⋮\\ p_{T^{\prime }(i,k)}^T-p_{T^{\prime }(i,1)}^T\end{array}\right)}^T\right]}^{1/2}\forall i=1,\dots ,{\delta }^{\prime }$ 3: else if chosen property is largest side then 4:     ${\rho }_i\leftarrow$ largest side of simplex with vertices $\{p_{T^{\prime }(i,1)},\dots ,p_{T^{\prime }(i,k)}\}$ 5: else if chosen property is condition number then 6:     ${\rho }_i\leftarrow \kappa \left(\begin{array}{c}{p}_{T^{\prime }(i,1)}\\ p_{T^{\prime }(i,2)}\\ ⋮\\ p_{T^{\prime }(i,k)}\end{array}\right)$                    ▹$\kappa \left(A\right)$ is the condition number of matrix A 7: end if 8: $\rho \leftarrow {\sum }_{i=1}^{{\delta }^{\prime }}{\rho }_i$ 9: $T\leftarrow T^{\prime }$ 10: if  ${\rho }_i>\tau ·\rho$  then 11:     remove triangle i from T 12: end if 13: return T, number of triangles $\delta$

4.4. Reduction

Once we have computed the filled set F, we need to select N points that are ideally evenly distributed along F. To this end, we use k-means clustering with N clusters, as there is a strong relationship between k-means and the optimal IGD subset selection [59,60]. The resulting N cluster centroids form the PF reference set Z. The use of k-means for reduction can be modified in the RSG code; alternatives such as k-medoids and spectral clustering are also supported (this is an input parameter in the code). Note that this reduction step can be further adapted to generate reference sets tailored to other types of indicators (i.e., those that are not distance-based), since one of the output of RSG the raw filled set F.

4.5. Obtaining $A_y$

The RSG requires an initial approximation $A_y$ of the Pareto front. Note that by construction of the algorithm, this set can have small imperfections (which can be removed by the filling step) and can also have biases in the approximation (reduction step). However, it is desired that $A_y$ “captures” the shape of the entire Pareto front. In particular, the RSG is not capable of detecting if an entire region of the Pareto front is missing in $A_y$. The computation of such an approximation is certainly problem-dependent. For our computations, we have used the following three main procedures to obtain $A_y$, depending on the complexity of the PF shape:

-

Sampling: In the easiest case, either the PS or the PF is given analytically, which is indeed given for several benchmark problems. If a sampling can be performed directly in objective space (e.g., for linear fronts), the remaining steps of the RSG may not be needed to further improve the quality of the solution set. If the sampling is performed in decision variable space, the elements of the resulting image $A_y$ are not necessarily uniformly distributed along the Pareto front as discussed above. However, in that case, the filling and reduction steps may help to remove biases. We have used sampling, e.g., for the test problems DTLZ1, CONV3, and CONV3-4.

-

Continuation: If neither the PS nor the PF has an “easy” shape, one alternative is to make use of multi-objective continuation methods, probably in combination with the use of several different starting points and with a non-dominance test. In particular, we have used the Pareto Tracer (PT, [61,62]), which is a state-of-the-art continuation method that is able to treat problems of, in principle, any dimensions (both n and k), can handle general constraints, and that can even detect local degeneration of the solution set. Continuation is advisable if the PS/PF consists of relatively few connected components and if the gradient information can at least be approximated. We have used PT, e.g., for the test problems WFG2, DTLZ5, and DTLZ6.

-

Archiving: The result of an MOEA or any other MOP solver can, of course, be taken. This could be either the final archive of the population, via merging several populations of the same or several runs [52], or via using external (unbounded) archives [43]. Note that this includes taking a reference set from a given repository. Archiving is advisable if none of the above techniques can be applied successfully.

We have used archiving, e.g., for the test problems DTLZ1-4, DTLZ7, ZDT1-6, CONV3, CONV3-4, and CONV4-2F.

4.6. Complexity Analysis

The overall time complexity is $\mathcal{O}(\gamma {\ell }^2+{\tau }_{2}Nk{N}_f)$ for $k=2$ (regardless of the number of components) and $\mathcal{O}(\gamma {\ell }^2+\delta k^2+{\tau }_{2}Nk{N}_f)$ for $k\ge 3$, where ℓ is the size of the initial approximation $A_y$, k is the number of objectives, $\delta$ is the number of triangles in the Delaunay triangulation, ${\tau }_2$ is the number of iterations of k-means (bounded to 500 in this work), N is the desired size of the reference set Z, and $N_f$ is the size of the filling. This assumes that $\ell \gg k$ and that the triangle-cleaning method used is based on the longest side (which was the method applied to all the references presented in this work). Typically, obtaining a decent approximation requires a large value of $N_f$, making the clustering step the dominant one and thus reducing the overall complexity to $\mathcal{O}\left({\tau }_{2}Nk{N}_f\right)$ for any k. We now present the time complexity analysis in detail for each step separately, considering a single component:

• Component Detection: The time complexity is $\mathcal{O}({(\ell )}^2+\gamma (\ell log(\ell )+{(\ell )}^2))$, which accounts for the computation of the average distance plus the size of the grid search ($\gamma$) multiplied by the sum of the complexities of DBSCAN and the WeakestLink computation. Here, ℓ is the size of $A_y$, and $\gamma$ represents the number of parameter combinations of the grid search, with $\gamma =14$ for $k=2$ and $\gamma =10$ for $k\ge 3$ using the suggested values for the case where no information about the PF is known a priori. If it is previously known that the Pareto front is connected, then the parameters of DBSCAN can be correctly adjusted, and $\gamma$ can be set to 1.
• Filling: The time complexity depends on the number of objectives:

  -

  For $k=2$, the time complexity is $\mathcal{O}(\ell +k{N}_f)$, which accounts for sorting and placing the $N_f$ points along the line segments.

  -

  For $k\ge 3$, the time complexity is $\mathcal{O}([k\ell +k{(k-1)}^2]+\ell k^2+\ell log\ell +[(k-1)\delta +k{N}_f])$ due to the computations involved in determining the normal vector $\eta$, changing coordinates and projecting, performing the Delaunay triangulation, and filling the triangles. Here, $\delta$ represents the size of the cleaned Delaunay triangulation, i.e., the number of triangles. Additionally, triangle cleaning must be considered, though its complexity depends on the method used. It is given by $\mathcal{O}\left(\delta k^3\right)$ when the cleaning is based on area or the condition number (due to determinant computation) or $\mathcal{O}\left(\delta k^2\right)$ when the cleaning is based on the longest side.

• Select Reference Set T: The time complexity is $\mathcal{O}\left({\tau }_{2}Nk{N}_f\right)$ due to the k-means clustering algorithm. Here, ${\tau }_2$ is the number of iterations of k-means.

The space complexity of RSG is dominated by the reduction step (i.e., k-means) and is given by $\mathcal{O}\left(k(N_f+N)\right)$, where k is the number of objectives, $N_f$ is the size of the filling set, and N is the desired reference set size. Since typically $N_f\gg N$, the complexity simplifies to $\mathcal{O}\left(k{N}_f\right)$.

5. Numerical Results

In this section, we show the strength of the novel approach on selected benchmark test problems. We further show—as far as possible—comparisons to related methods. See Appendix A for the definitions of the test problems CONV3, CONV3-4, and CONV4-2F.

First, we demonstrate the working principle of the RSG on selected test problems with different characteristics (number of objectives, choice of the initial set $A_y$, and shape of the Pareto front). For all problems, we show all the main steps of the RSG: initial solution, component detection, filling, and the selection. For the latter, we show the obtained reference sets for different values of N to show the effect of the new method. In particular, we have used the following six test problems (refer to Figure 8, Figure 9, Figure 10, Figure 11, Figure 12 and Figure 13): ZDT3 ($k=2$ objectives, disconnected, and convex–concave Pareto front), DTLZ7 ($k=3$, disconnected, and convex–concave PF), WFG2 ($k=3$, disconnected, and convex PF, where the latter refers to each connected component), CONV3 ($k=3$, connected, and convex PF), CONV3-4 ($k=3$, connected, and convex PF, where one part of the PF is nearly degenerated), and CONV4-2F ($k=4$, disconnected, and convex PF). Note that the starting sets $A_y$ for ZDT3 and DTLZ7 contain (slight) biases that were removed by the RSG. The applicability to CONV3, CONV3-4, and CONV4-2F show the universality of the RSG: in contrast to other methods that generate reference sets, the RSG does not, in principle, need any analytical information of the PF. It requires, however, a “suitable” initial solution $A_y$, which is a non-trivial task and is problem-dependent. Refer to Section 4.5 for general guidelines. In the captions of Figure 8, Figure 9, Figure 10, Figure 11, Figure 12 and Figure 13, we describe how we obtained this set for each problem.

Figure 14 shows some numerical results of the RSG on DTLZ1 and DTLZ2 with and without the filling step. As can be seen, the candidate solutions are more evenly distributed when using the filling. Without filling, a bias can be observed on the top end of the fronts similar to uniform sampling along the Pareto set (refer to Figure 3 and Figure 4 and the related discussion).

Table 2. RSG running time (in seconds) for bi-objective problems varying the size of the filling set ($N_f$). The size of $A_y$ was fixed at 100 for all problems, and the size of the final reference set was set to $N=100$.

	${\mathit{N}}_{\mathit{f}}$ =	1000	5000	10,000	50,000
ZDT1		0.050	0.127	0.434	11.548
ZDT3		0.030	0.097	0.266	6.272
ZDT4		0.016	0.086	0.289	6.639
ZDT6		0.015	0.093	0.376	9.296

and

Table 3. RSG running time (in seconds) for problems with $k=3$ objectives varying the size of the filling set ($N_f$). The size of $A_y$ was set to 300, 1024, 1134, and 990 for DTLZ2, DTLZ7, C2_DTLZ2, and CDTLZ2, respectively. The size of the final reference set was fixed at $N=300$.

	${\mathit{N}}_{\mathit{f}}$ =	10,000	50,000	100,000	500,000	1,000,000
DTLZ2		0.271	3.164	8.059	235.510	1049.119
DTLZ7		1.305	3.359	7.962	230.973	981.419
C2_DTLZ2		1.710	3.698	8.510	216.197	1025.821
CDTLZ2		0.329	3.595	9.452	247.404	1013.905

show the running times (in seconds) of the RSG on selected bi-objective and three-objective problems for different filling sizes. We used for the starting set $A_y$ the reference provided by PlatEMO, with a size of 100 for bi-objective problems and a problem-dependent size for three-objective problems. The size of the final reference set was fixed at 100 for bi-objective and 300 for three-objective problems. Naturally, the larger the filling size, the longer the runtime of the RSG. However, reference sizes of 100 and 300 are typically standard for comparisons, meaning that, in general, the RSG only needs to be run once per problem.

Additionally, a comparison between the RSG, PlatEMO [50], pymoo, and filling step is presented in Figure 15 and Figure 16 for the WFG2, ZDT1, ZDT3, DTLZ2, Convex DTLZ2 (CDTLZ2), C2-DTLZ2, and DTLZ7 test problems. Although the reference sets provided by PlatEMO and pymoo are of high quality, they still exhibit some bias in certain bi-objective problems (such as ZDT1 and ZDT3) and especially in three-objective problems such as WFG2, and CDTLZ2. Furthermore, for problems like WFG2 and DTLZ7, the number of points in the reference sets of PlatEMO and pymoo is limited to a fixed set in contrast to the RSG, which can generate any desired number of points.

6. Conclusions and Future Work

In this paper, we have addressed the problem of obtaining bias-free and complete finite-size approximations of the solution sets (Pareto fronts) of multi-objective optimization problems (MOPs). Such approximations are, in particular, required for the fair usage of distance-based performance indicators, which are frequently used in evolutionary multi-objective optimization (EMO). If the Pareto front approximations are biased or incomplete, the use of these performance indicators can lead to misleading or false information. To address this issue, we have proposed the Reference Set Generator (RSG). This method starts with an initial (probably biased) approximation of the Pareto front. An unbiased approximation is then computed via component detection, filling, and a reduction to the desired size. The RSG can be applied to Pareto fronts of any shape and dimension. We have finally demonstrated the strength of the novel approach on several benchmark problems.

In the future, we intend to use the RSG on the Pareto fronts of all commonly used continuous test problems. Special attention has to be paid to problems with degenerated fronts (i.e., problems where the Pareto front does locally not form an object of dimension $k-1$). In the current approach, we handled degeneracy using the Pareto Tracer (PT) to obtain a filled set and, from there, used the reduction step. For future work, we will explore if the projection can be modified to fill such sets, which may lead to a more general approach to handling degeneration.

Another important aspect is scalability. In order to apply the method to higher dimensional problems, variants have to be considered that are less costly. For example, to avoid performing a grid search, alternative parameter selection methods can be explored. Similarly, for the reduction step, a faster k-means variant or a different subset selection method could be used. A study on the effect of k-means initialization is also left as future work. Next, we stress that we have designed the RSG for Pareto front approximations. There are, however, other interesting sets of interest in the context of multi-objective optimization that may be worth investigating. This may include the entire Pareto set or locally optimal solutions, as considered in multi-objective multi-modal optimization (e.g., [38,63]) or the families of Pareto sets/fronts in the context of dynamic multi-objective optimization [64].