Céline Anne Diana

Mehdi George

Amine, Meriem Youcef Alexandre

Amine, Dalal, Edouard Abdallah

Nat Lydia

Cédric

Pedro Khalil

Fabien, Fabiola Christophe Doris

Pauline Ald

Pauline Ali Pauline

À mes deux encadrants, merci à Tristan Cazenave et Daniel Vanderpooten d'avoir accepté de diriger ma thèse. Leurs enseignements ont été précieux pour moi et cette thèse m'a permis d'apprendre une quantité incroyable de choses dont je suis persuadé qu'elles me seront essentielles pour l'avenir. Je les remercie de la bienveillance dont ils ont fait preuve à mon égard ainsi que l'autonomie qu'ils m'ont laissée dans mon travail. Au travers de leur proposition de stage de M2, je les remercie de m'avoir introduit dans cet univers qu'est la recherche en informatique dont j'ignorais tout, ainsi que de m'avoir fait rencontré des gens aussi passionants que passionnés. Je remercie Tristan d'avoir accepté de jouer le rôle de directeur officiel avec l'administratif que cela induit, et Daniel d'avoir organisé notre classe "optimisation multi-objectif" à Wuppertal qui fut un bon souvenir.

Aux membres du jury, je remercie chaleureusement Xavier Gandibleux et Laetitia Jourdan qui ont accepté d'être rapporteurs de ma thèse, ainsi que Thibaut Lust et Frédéric Saubion, qui ont accepté d'être examinateurs. Je remercie tous les membres du jury pour leur relecture de ma thèse, d'autant plus que je les sais être des personnes très demandées dans leur travail.

Aux enseignants et chercheurs de Dauphine et d'ailleurs, je remercie Anne Epaulard pour son aide sur le problème des régions. Merci à toute l'équipe du LAMSADE, en particulier Cristina Bazgan et Lucie Galand qui étaient du voyage à Wuppertal, ainsi que l'équipe multiobjectif de l'Université de Wuppertal pour leur accueil chaleureux : Britta, Kathrin, Kerstin et Michael. Je remercie aussi les enseignants que j'ai pu avoir durant mes études à Dauphine. En particulier, je remercie Attila Raksanyi de m'avoir donné une sorte de seconde chance

Introduction

Nowadays, companies and even people are frequently faced with problems of discrete nature, called combinatorial optimization problems. A combinatorial problem involves managing (selecting a subset of or ordering) a finite set of elements while respecting a number of constraints. These elements are the elementary components of the solutions of the problem. The quality of a solution of the problem is evaluated by an objective (also called criterion) value. When two solutions are compared, either one solution is better than the other given this objective, or both have the same objective value. The aim of Combinatorial Optimization is to find one (or even several) of the best solutions of the problem.

Combinatorial optimization problems are numerous in today's lives and appear in various situations. A simple example of such problems would be the packing of your bag before vacations. This situation forces you to select carefully the most useful stuffs for your trip, knowing that your bag has a limited place. Another situation regularly experienced by anyone is to find the shortest path for moving from a location to another, regardless of the mean of transport; problem generally solved by geolocation systems (Galileo, GPS, ...) embedded in some portable devices, or even solved by web applications. Companies are also confronted to combinatorial optimization problems specific to their field of activity. For example, an airline company faces each day the problem of combining schedules of thousands of flight attendants, in order to operate all the daily flights with a minimum cost. Telecommunications companies (Orange, AT&T, ...) are extensively confronted to different combinatorial optimization problems. Among them, an important issue is related to the design of a telecommunication network: how to connect a number of homes of a village or a city block to Internet with high-speed access minimizing the total length of the cables used? Another example concerns the service of any delivery company (La Poste, Fedex, ...), which has to deliver packages to a set of customers by using a fleet of transport vehicles. The problem arising each day is to deliver packages while minimizing either the total fuel consumed or the total distance covered by all vehicles through their traveling from the warehouses to the consumers.

There are many different methods to optimize combinatorial problems but we can categorize them into two main classes : exact methods and approximation methods. Exact methods aim at finding an optimal (i.e. best) solution of the problem, while the purpose of approximation methods is to find a sub-optimal (i.e. approximate) solution of good quality. There are two sub-classes of approximation methods: the approximation methods with performance guarantee and the heuristics. The approximation methods with performance guarantee provide a sub-optimal solution guaranteed to be optimal at a given precision. A heuristic does not provide any guarantee on the quality of the solution generated. In addition to the quality, a key aspect of all these methods is to provide a solution in a time said to be reasonable. In general, guaranteeing the quality of a solution takes extra time compared to a method not providing any guarantee, and proving that a solution is optimal takes even more extra time. Therefore, each one of these three classes of methods is useful depending on the difficulty of finding an optimal solution for the addressed problem. Globally, the difficulty of the instance of a problem depends on two main axes: the number of elements composing the instance (called the size of the instance) and the type of constraints involved. Concerning problems said to be easy, like the Shortest Path Problem or the telecommunication network design problem previously cited, exact methods generally provide an optimal solution in a reasonable time, even for large-size instances. On the other hand, for problems similar to the first given example, called Packing Problems, it 1 may be difficult for an exact method to find a solution in a reasonable time and it might be advisable to use instead an approximation method with performance guarantee to reduce the execution time for finding a good quality solution. Finally, concerning the presented problem faced by the delivery companies, called the Vehicle Routing Problem, it is considered as a hard problem, and even for small instances, an exact method will have great difficulties to find an optimal solution. Optimizing an instance of such a problem with an approximation method with performance guarantee is realistic up to a certain size, but for large-size instances only heuristics are able to find good quality solutions in a reasonable time.

Such hard problems like the Vehicle Routing Problem belong to the class of NP-hard problems [START_REF] Garey | A guide to the theory of npcompleteness[END_REF]. A conjecture widely accepted nowadays states that the time necessary to find an optimal solution of a NP-hard problem is, in the worse case, exponential in the size of the instance, making a proof of optimality infeasible in practice or even a good performance difficult to guarantee as the size of realworld instances is often too large. Meta-heuristics, which are heuristics proposing a general framework to optimize different problems, are extensively used for such NP-hard problems [Dréo et al., 2003, Gendreau and[START_REF] Gendreau | [END_REF]. There is a wide range of different meta-heuristics for combinatorial problems, among others: evolutionary algorithms [Goldberg, 1989, Bäck et al., 1997], local search methods [START_REF] Kirkpatrick | Optimization by simulated annealing[END_REF], Glover, 1989, Feo and Resende, 1995, Hoos and Stützle, 2004], nature-inspired meta-heuristics [Dorigo et al., 2006, Kennedy and[START_REF] Kennedy | [END_REF], Monte Carlo Search methods [Ginsberg, 2001, Gelly and Silver, 2007, Browne et al., 2012].

At this point, we have considered the optimization of a single objective. On the other hand, solutions of combinatorial problems may be evaluated on several objectives, often conflicting. Conflicts between objectives generally lead to the following fundamental difference with single-objective optimization: two solutions can have different objective values, representing different trade-offs of the objectives, and consequently none is better than the other. Optimizing together several objectives of a combinatorial problem gave rise to the domain of Multi-Objective Combinatorial Optimization (MOCO).

A classical example of conflicting objectives concerns routing problems like the Shortest Path Problem or the Vehicle Routing Problem previously presented. For such problems, several objectives can be considered: the travel time, the ecological footprint and naturally the travel cost depending on the mean of transport chosen. We can easily see that a number of these objectives are generally conflicting, like the travel time versus the travel cost or the ecological footprint. However, as a topical example, it can be interesting for an environment-conscious company (or even a person) to select a route optimizing both travel time and its ecological footprint. Considering such an extra ecological-oriented objective would benefit the company by promoting its environment-consciousness for attracting more customers. Concerning the scheduling problem faced by the airplane company, in addition to the cost minimization, we could consider as second objective the well-being of flight attendants, by taking into account their preferences of working days. Although potentially conflicting with a minimization of costs, optimizing as well the well-being of employees would potentially reduce social movements and also improve the brand image of the company. Another example of conflicting objectives appears in a common problem faced in finance. It consists in choosing a portfolio out of a given set of investment proposals while optimizing two conflicting objectives: the expected value of portfolio returns to maximize, and the risk inherent to portfolio returns to minimize. More generally, MOCO presents numerous real world applications in finance, transportation, medicine and telecommunication [Ehrgott, 2009], routing problems and telecommunications [START_REF] Gabrel | Enumeration and interactive selection of efficient paths in a multiple criteria graph for scheduling an earth observing satellite[END_REF], Martins and Ribeiro, 2006, Madakat et al., 2013, Zavala et al., 2014], structural design problems [START_REF] Clímaco | Multicriteria path and tree problems: discussion on exact algorithms and applications[END_REF]. ods with performance guarantee and (meta-)heuristics. In addition to this methodology classification, three main approaches exist in MOCO and each one is more or less demanding for the decision maker [START_REF] Deb | Multi-objective optimization[END_REF]. The first one is the interactive approach, which iteratively interacts with the decision maker by asking him/her preferences through the selection, classification or ranking of different solutions suggested by the method in order to guide the search, and to finally obtain a solution that suits him/her [Roy, 1985, Vanderpooten and[START_REF] Vanderpooten | [END_REF]]. The second one is the a priori approach which aims at first asking the preferences of the decision maker among all objectives, then focus the optimization process given these guidelines. At the end, the method produces a single or a small set of solutions. These two types of approaches often aggregate the objectives into a single one such that the problem can then be solved as a single-objective problem. A wide variety of aggregations can be found in the literature, from weighted sum or weighted Tchebychev [START_REF] Belhoul | An efficient procedure for finding best compromise solutions to the multi-objective assignment problem[END_REF] to more complex ones able to model complex decision maker's preferences as the Choquet integral [Galand et al., 2010, Lust andRolland, 2013]. The third one is the a posteriori approach, for which the preferences of the decision maker are not known a priori, i.e. before the optimization process of the problem. This approach is strongly attached to the notion of Pareto dominance: a solution dominates another solution if it is equal or better on all objectives and strictly better on at least one objective. Considering this notion, the decision maker would not be interested in dominated solutions, and consequently the aim of an a posteriori approach is to find the whole set of solutions not dominated by any other solution, called the efficient set. Despite the fact that in practice we search for a reduced efficient set, i.e. an efficient set such that only a single solution is memorized among equivalent ones, the set may be extremely large, particularly in the case of multiple and conflicting objectives. Thus, even for moderately-sized problems, it is usually computationally prohibitive to identify an exact reduced efficient set. In particular, several MOCO problems are intractable, in the sense that the number of points can be exponential in the size of the instance [Ehrgott, 2006]. That is why, in addition to the inherent difficulty of MO problems previously mentioned, exact methods finding an exact reduced efficient set are generally used for easy problems or small instances of harder problems. On the other hand, given a predefined tolerance in the dominance relation, approximation methods with performance guarantee will be able to find an approximation of the efficient set hence exact methods become impracticable. These approximation methods seem to be efficient in theory [START_REF] Papadimitriou | On the approximability of trade-offs and optimal access of web sources[END_REF] as in practice for certain problems [Bazgan et al., 2009a]. Finally, meta-heuristics do not provide any guarantee of performance on the quality of the approximation set found, but due to their practical effectiveness, they are currently massively used to optimize (large instances of) hard problems. Indeed, single-objective meta-heuristics have been adapted to MOCO, such as MO Evolutionary Algorithms [START_REF] Coello | Evolutionary algorithms for solving multi-objective problems[END_REF], MO local search [START_REF] Ulungu | Heuristic for multiobjective combinatorial optimization problems with simulated annealing[END_REF], Hansen, 1997, Talbi et al., 2001, Paquete et al., 2004, Vianna and Arroyo, 2004], MO nature-inspired meta-heuristics [START_REF] Barán | A multiobjective ant colony system for vehicle routing problem with time windows[END_REF], López-Ibáñez and Stützle, 2012, Xue et al., 2013], and more recently MO Monte Carlo Search [START_REF] Wang | Multi-objective monte-carlo tree search[END_REF]. Once (an approximation of) the efficient set has been found, the decision maker chooses the solution which fits the best to his/her preferences using Multiple Criteria Decision Aid method [START_REF] Greco | Multiple criteria decision analysis[END_REF].

Scope of the thesis

In this thesis, we are interested in designing data structures and meta-heuristics for finding approximation of efficient set of MOCO problems. The main point of the thesis is to propose new and efficient (in terms of time and quality) methods, independent of the addressed problem as far as possible, and scalable both in the size and in the number of objectives of the instance. Indeed, we did not limit ourselves to the biobjective case, and have considered problems with up to 5 objectives. Moreover, the proposed tools are modular, in the sense that they can be used independently from each other. Due to recent successes of local search on hard MOCO problems [START_REF] Li | An elitist grasp metaheuristic for the multiobjective quadratic assignment problem[END_REF], Ke et al., 2014[START_REF] Lust | Variable and large neighborhood search to solve the multiobjective set covering problem[END_REF], we are particularly concerned by introducing new tools for MO local search, Single-Objective (SO) optimizers and data structures. As a secondary axis, considering recent development of efficient Monte Carlo Search methods on many SO optimization problems [START_REF] Browne | A survey of monte carlo tree search methods[END_REF], Edelkamp et al., 2016], we are also interested in the combination of Monte Carlo Search methods with MO local search.

Outline of the thesis

Chapter 1 recalls fundamental definitions and notions of MOCO. Chapter 2 exposes an overview of methods for optimizing MOCO problems, focusing on meta-heuristics. The chapter also presents a literature review of methods on MO symmetric Traveling Salesman Problem (MOTSP), focusing on meta-heuristics and exposes the state-of-the-art of archives, which are sets of mutually non-dominated solutions. Chapter 3 deals with the new proposed archives: AVL-Archive for bi-objective optimization problems and NDR * -Archive for the general case. The experimental results on artificial and MOTSP benchmarks are presented. Chapter 4 introduces the new tools proposed to optimize MOCO problems: a new MO meta-heuristic called 2-Phase Iterated Pareto Local Search with Decomposition (2PIPLS/D), embedding Adaptive Maximally Dispersed set of Weights (A-MDW) for generating an initial population, Partitioned Pareto Local Search (P-PLS) as a speed-up technique for PLS, and some modifications on SO optimizers to improve their efficiency on MOCO problems. Chapter 5 is devoted to the application of 2PIPLS/D to MOTSP on a benchmark of bi-objective and tri-objective instances, and proposes an empirical evidence of global convexity on MOTSP. Finally, Chapter 6 introduces the MO version of the French Regions Mapping Problem and shows the application of 2PIPLS/D to this new five-objective problem.

Introduction

In a MOCO problem, several objectives are taken into account, which often leads to obtain incomparable solutions representing different possible trade-offs between objectives. Section 1.1 first recalls the formal definition of a MOCO problem, then introduces important notions and techniques of MOCO. Section 1.2 presents a number of classical theoretical MOCO problems.

Fundamental concepts and techniques

Problem setting

Let E be a finite set of q elements E := {e 1 , ...e q }, defining a combinatorial structure. Let c j : E → R, j = 1, ..., p, be the p cost functions that map each element of E with a vector of p costs, and c = (c 1 , ...c p ) be the multi-objective cost function.

Considering the minimization version, a MOCO problem is defined as:

min f (x) = (f 1 (x), ..., f p (x)) subject to x ∈ X (1.1)
where X ⊂ 2 E = {0, 1} q is the feasible set and the p potentially conflicting objective functions f j : X → R mapping solutions to R, for j = 1, ..., p.

Given a feasible solution x ∈ X, an objective function can take several functional forms: usually additive, i.e. f j (x) = e∈x c j (e), sometimes bottleneck, i.e. f j (x) = max e∈x c j (e), or even more complex non linear forms.

The vector function f = (f 1 , ..., f p ) hence maps solutions to points in the objective space Z ⊂ R p . Let Y := f (X) ⊂ Z be the set of all feasible points.

Dominance relations

Points in the objective space are compared using the concept of Pareto dominance. For any points z, z ∈ Z, we define the following relations:

• z weakly dominates z , denoted by z z , iff. z j ≤ z j for each j = 1, ..., p

• z strictly dominates z , denoted by z < z , iff. z j < z j for each j = 1, ..., p

• z dominates z , denoted by z ≤ z , iff. z j ≤ z j for each j = 1, ..., p and there exists i ∈ {1, ..., p} such that z i < z i

• z and z are incomparable, denoted by z z , iff. z z and z z

We can introduce a tolerance in the above dominance relations by defining an approximate dominance relation. This can be relevant if small differences between objective values are judged non significant. For any points z, z ∈ Z and given a tolerance > 0, we define the following relations:

• z -dominates z , denoted by z z , iff. z j ≤ (1 + )z j for each j = 1, ..., p

• z and z are -incomparable, denoted by z z , iff. z z and z z

In addition, these original definitions are propagated in the decision space as follows, for any x, x ∈ X :

• x weakly dominates x , denoted by x x , iff. f (x) f (x )

• x strictly dominates x , denoted by x < x , iff. f (x) < f (x )

• x dominates x , denoted by x ≤ x , iff. f (x) ≤ f (x )

• x -dominates x , denoted by x x , iff. f (x) f (x )

• x and x are -incomparable, denoted by x x , iff. f (x) f (x ) and f (x ) f (x)

Non-dominance and efficiency

A point z ∈ Y is called non-dominated if and only if there is no other point z ∈ Y such that z ≤ z. In other words, a non-dominated point is a point such that no improvement on any objective is possible without sacrificing on at least another objective. A feasible solution x ∈ X is called efficient if its image in the objective space is non-dominated.

The set of all non-dominated points Y nd ⊆ Y is called the non-dominated set (or Pareto front). The set of all efficient solutions X e ⊆ X is called the efficient set.

Given a tolerance > 0, a set of points Y nd ⊂ Y is called an -approximation of the non-dominated set Y nd if any point z ∈ Y nd is -dominated by at least one point z ∈ Y nd [START_REF] Papadimitriou | On the approximability of trade-offs and optimal access of web sources[END_REF]: ∀z ∈ Y nd , ∃z ∈ Y nd : z z.

Ideal and nadir points

Let z * = (z * 1 , ..., z * p ) ∈ Z be the ideal point, which has the best values for each objective:

z * j = min x∈X f j (x) for j = 1, ..

., p

Let η = (η 1 , ..., η p ) ∈ Z be the nadir point, which has the worst values for each objective on the non-dominated set:

η j = max x∈Xe f j (x) for j = 1, ..., p
Let X ⊂ X be a subset of incomparable solutions.

The local ideal point z * (X ) ∈ Z of X is the point with the best objective values among all solutions belonging to X : z * j (X ) = min x∈X {f j (x)}, j = 1, ..., p

The local nadir point η(X ) ∈ Z of X is the point with the worst objective values among all solutions belonging to X : η(X ) = max x∈X {f j (x)}, j = 1, ..., p

Approximations of these extreme points can be introduced.

An approximate local ideal point z * (X ) ∈ Z of X is a point which weakly dominates z * (X ), i.e. such that z * (X ) z * (X ).

An approximate local nadir point η(X ) ∈ Z of X is a point which is weakly dominated by η(X ), i.e. such that η(X ) η(X ).

Naturally, both z * (X ) and z * (X ) weakly dominate all solutions from X , and all solutions from X weakly dominate both η(X ) and η(X ).

A Minimum Bounding Box (MBB) of a set of spatial objects (resp. points) in Z is a hyper-rectangle of minimum hypervolume including all the objects (resp. points). It is uniquely defined by a pair of local ideal and nadir points.

Aggregation functions

An aggregation function aims at aggregating the objectives of a MOCO problem so that the resulting problem is a single-objective problem. Two aggregation functions are used in this document: the weighted sum and the weighted augmented Tchebychev functions, detailed below.

Weighted sum

Let λ = (λ 1 , ..., λ p ) ∈ R p such that λ j ≥ 0 for j = 1, ..., p, be a weighting vector (called weight). The weighted sum problem is given by:

     min λf (x) = p j=1 λ j f j (x) subject to x ∈ X (1.2)
The resulting aggregated problem is a single-objective instance of the original MOCO problem.

Weighted augmented Tchebychev

Let λ = (λ 1 , ..., λ p ) ≥ 0 be a weight. The weighted augmented Tchebychev problem is given by:

    
min wat(x, λ, z * ) = max j=1,...,p

λ j (f j (x) -z * j ) + ε p j=1 λ j (f j (x) -z * j ) subject to x ∈ X (1.3)
where ε > 0 is a fixed small positive real.

The weighted Tchebychev problem is a weighted augmented Tchebychev problem with ε = 0.

Supported and non-supported solutions

Supported efficient solutions are optimal solutions of a weighted sum problem for some vector λ > 0 [Geoffrion, 1967]. Let conv(Y ) be the convex hull of the set of all feasible points. The images in the objective space of the supported efficient solutions correspond to the supported non-dominated points, which are nondominated points located on conv(Y ).

The set of all supported efficient solutions is called the supported efficient set, and the set of all supported non-dominated points is called the supported non-dominated set.

We can make a distinction between supported efficient solutions:

1.1. FUNDAMENTAL CONCEPTS AND TECHNIQUES

• Extreme supported efficient solutions, whose image in the objective space, called extreme supported non-dominated points, are non-dominated points located on the vertex set of conv(Y ).

• Non-extreme supported efficient solutions, whose image in the objective space, called non-extreme supported non-dominated points, are not located on the vertex set of conv(Y ).

• • • • • • • • • • f 1 f 2 • • • • • • • • • • f 1 f 2 • • • • • • • • • • f 1 f 2 Figure 1
.1 -Extreme supported non-dominated points (left part), a non-extreme supported non-dominated point (middle part), non-supported non-dominated points (right part). The gray area represents the convex hull of the set of all feasible points conv(Y ).

Non-supported efficient solutions are efficient solutions that are not optimal solutions for any weighted sum problem with λ > 0. The image in Y of the non-supported efficient solutions are the non-supported nondominated points, located in the interior of conv(Y ).

Figure 1.1 summarizes the different types of non-dominated points.

By taking into consideration these different types of solutions, a distinction can be made between weighted sum and weighted augmented Tchebychev functions. Indeed, in contrast with weighted sum, optimizing a weighted augmented Tchebychev function with the appropriate weight allows us to find any efficient solution (not only a supported one) at the expense of a harder problem to solve.

Weight space and generation of weights

A closed subset Λ ⊂ R p is called a d-dimensional simplex in R p (d ≤ p) if Λ
is the convex hull of d + 1 affinely independent points λ 1 , ..., λ d+1 ∈ R p . More formally:

Λ = {λ ∈ R p : λ = d+1 j=1 w j λ j , w j ∈ [0, 1], d+1 j=1 w j = 1}
Any point of a simplex can be expressed as a linear combination of the vertices of the simplex. We note Λ = (λ 1 , ..., λ d+1 ) to indicate that λ 1 , ..., λ d+1 are the vertices of Λ.

Let

Λ 0 := {λ ∈ R p : λ j ≥ 0, j = 1, ..., p, p j=1 λ j = 1} be a (p-1)-dimensional simplex in R p , called the normalized weight space (or simply the weight space). Λ 0 contains all the positive weights normalized to unity. Generally, any weight generated for optimizing a given aggregation function will belong to the normalized weight space Λ 0 .

• • • • • • • • • • • • • • • • • • (0, 0, 1) (0, 1, 0)
(1, 0, 0)

( 1 2 , 1 2 , 0) (0, 1 2 , 1 2 )

( 1 2 , 0, 1 2 )

Figure 1.2 -Set of 15 weights (black dots) generated in Λ 0 by MDW with D = 4 and p = 3. Some vectors are indicated as examples.

A method often used to create weights into Λ 0 is the Maximally Dispersed set of Weights (MDW) [Steuer, 1986] which produces a number of equally dispersed weights into Λ 0 (see Figure 1.2). Given a parameter D ∈ N * controlling the number of weights generated, MDW provides the set of weights given by:

Complexity, intractability and examples of MOCO problems

The difficulty to generate the efficient set comes essentially from two main issues:

• the complexity of the addressed problem;

• the potentially extremely large number of non-dominated points.

Concerning the complexity of a problem, we will simply oppose problems for which the decision version is polynomially solvable in time given the size of the instance; and problems with a NP-hard decision version, for which a conjecture widely accepted states that the problem is, in the worst case, exponentially solvable in time given the size of the instance.

Concerning the second issue, a situation often encountered is that the addressed problem is intractable, meaning that the number of non-dominated points can be exponential in the size of the instance.

We can list some classical MOCO problems, among others: MO Minimum Spanning Tree, MO (Quadratic) Assignment Problem, MO (Multidimensional) Knapsack Problem, MO symmetric / asymmetric Traveling Salesman Problem. Let us detail three of them:

COMPLEXITY, INTRACTABILITY AND EXAMPLES OF MOCO PROBLEMS

MO Assignment Problem

In MO Assignment Problem (MOAP), n agents have to be assigned to n machines. Each couple (agent,machine) has a cost vector. Any agent can be assigned to any machine.

It is required to assign exactly one agent to each machine and exactly one machine to each agent while minimizing the total cost. More formally, the combinatorial structure of MOAP is represented by a complete bipartite graph G = (V, E) with V the set of vertices, divided into two disjoint sets A = {a 1 , ..., a n } and M = {m 1 , ..., m n }, both of size n; and E = {(a k , m l ) : k, l = 1, ..., n} be the set of edges. MOAP is defined by (1.1), where f j (x) = e∈x c j (e) for j = 1, ..., p and X represents the set of all perfect matchings on G.

While the decision version of AP is polynomially solvable, the decision version of MOAP is NP-hard [Ehrgott, 2006].

MO 0-1 Knapsack Problem The MO 0-1 Knapsack Problem (MOKP) consists in inserting n items into a knapsack with a limited integer capacity W > 0. Each item k has a positive integer weight w k and p positive integer profits v k 1 , ..., v k p , k = 1, ..., n. A feasible solution is represented by a vector x = (x 1 , ..., x n ) of variables x k ∈ {0, 1}, such that x k = 1 if x contains item k and 0 otherwise, while satisfying the capacity constraint n k=1 w k x k ≤ W . MOKP is defined by (1.1), where f j (x) = n k=1 v k j x k is the value of a feasible solution x ∈ X on the j-th objective, j = 1, ..., p. Decision versions of both KP and MOKP are NP-hard [Ehrgott, 2006].

MO symmetric Traveling Salesman Problem

In symmetric Traveling Salesman Problem (TSP), a traveling salesman has to visit a set of cities without passing more than once through each city and returns to the starting city. A single cost value is associated to each edge between two cities. The goal is to find a tour such that the total cost is minimized.

In MO symmetric Traveling Salesman Problem (MOTSP), a cost vector is associated to each edge between two cities, and the traveling salesman has to minimize all the total costs. More formally, we define MOTSP as follows. Given a complete graph G = (V, E) with V = {v 1 , ..., v n } the set of n nodes and E = {e 1 , ...e q } corresponding to the set of edges such that q = n(n-1)

Introduction

There are many different general methods to deal with MOCO problems, categorized into two classes: exact methods and approximation methods. An exact method aims at finding the whole non-dominated set and providing one corresponding efficient solution for each point found. Numerous different general exact methods exist, like MO Branch-and-bound [Sourd and Spanjaard, 2008, Cerqueus et al., 2017, Przybylski and Gandibleux, 2017], MO Dynamic Programming [START_REF] Bazgan | Solving efficiently the 0-1 multi-objective knapsack problem[END_REF], -constraint [Haimes et al., 1971, Florios andMavrotas, 2014], two-phase methods [Ulungu andTeghem, 1995, Przybylski et al., 2010b] and recently, search region-based method [Lacour, 2014, Klamroth et al., 2015, Dächert et al., 2017].

Approximation methods aim at finding an approximation of the non-dominated set and memorizing a single solution for each point found. There are two types of approximation methods: those with performance guarantee and those without any performance guarantee, called heuristics. Approximation methods with performance guarantee (also called approximation methods with a priori guarantee) are methods introducing a tolerance in the dominance relation, in general the usual dominance relation ≤ is replaced by the epsilon dominance with a predefined . By relaxing the dominance relation, such methods are able to find a good approximation of the efficient set in a reasonable time, when exact methods become impracticable. These approximation methods with performance guarantee seem to be efficient in theory [START_REF] Papadimitriou | On the approximability of trade-offs and optimal access of web sources[END_REF] as in practice for certain problems (see for example [Bazgan et al., 2009a, Lacour, 2014]).

Both exact methods and approximation methods with performance guarantee are used on problems like MO Shortest Path Problem, MO Assignment Problem, MO 0-1 Knapsack Problem, MO Minimum Spanning Tree problem and others. But for harder problems like MOTSP, MO Multidimensional 0-1 Knapsack Problem or MO Quadratic Assignment Problem and many others, it is difficult in practice to obtain a valuable guarantee on the quality of the generated solutions in a reasonable time (see for example [Lust andTeghem, 2012, Florios andMavrotas, 2014]).

Optimization methods

Exact methods Approximation methods

Heuristics

Approximation methods with performance guarantee Problem-specific heuristics Meta-heuristics Figure 2.1 -A taxonomy of MOCO optimization methods.

To handle this difficulty, researchers have been interested in developing heuristics. Heuristics are subdivided into two sub-categories: problem-specific heuristics and meta-heuristics (see Figure 2.1 summarizing the different types of optimization methods). A meta-heuristic is a general heuristic method able to optimize different combinatorial problems using the same framework. The process of any meta-heuristic is based on two conflicting notions: intensification and diversification of the search. Intensification (also called exploitation) aims at intensifying the search towards promising regions of the search space, while the goal of diversification is to explore as much as possible the search space in order to find new promising regions. In meta-heuristics, randomness is extensively used to provide a certain degree of diversity to the search. A crucial dilemma of meta-heuristics consists in distributing the available computational resources between intensification and diversification.

While meta-heuristics do not provide any guarantee on the quality of the solutions found, they have the advantage of being computationally efficient, general, and relatively simple in implementation. Indeed, they are currently massively used to optimize problems for which exact and approximation methods with performance guarantee are impracticable. Because meta-heuristics only produce approximations of the efficient set, it is necessary to be able to evaluate the quality of any approximation in order to compare different meta-heuristics.

Section 2.1 presents three among the most popular quality indicators used to evaluate the quality of approximation sets generated by the meta-heuristics. Section 2.2 describes several meta-heuristics used in MOCO.

Then, Section 2.3 proposes a literature review of methods for MOTSP, focusing on meta-heuristics. Finally, Section 2.4 discusses about the different data structures published these last few years for managing a set of incomparable solutions, called archives.

MO quality indicators

In single-objective optimization, it is quite easy to measure the quality of a solution since it is to be compared with a unique value. It is a more difficult task in the MO case, because MO outputs are represented by sets of trade-off solutions, incomparable in terms of Pareto dominance. Consequently, we use several indicators, called quality indicators, to measure the quality of an approximation of the non-dominated set.

This section presents three of the most used quality indicators to compare approximation sets in MOCO: the hypervolume difference indicator I H - [Zitzler, 1999], the indicator I [START_REF] Zitzler | Performance assessment of multiobjective optimizers: an analysis and review[END_REF] and the R2 indicator I R2 [START_REF] Hansen | Evaluating the quality of approximations to the non-dominated set[END_REF]]. We use only the unary version of these indicators as they measure the quality of a single set, by contrast with the binary version measuring the difference of quality of a couple of sets.

The computation of these indicators implies to know the exact non-dominated set Y nd , which is generally unknown for a given instance of the addressed problem. Thus we approximate it by merging all the approximations generated during the experimental phase and keeping only the non-dominated points, forming the approximation of the non-dominated set Y nd . Let z * ∈ Z be the approximate ideal point defined as the ideal point computed on Y nd .

Hypervolume difference indicator

Given an approximation set A and a reference point z ∈ Z which is weakly dominated by every point of A, the hypervolume value of A with regard to z measures the hypervolume of the region of the objective space which is weakly dominated by A and weakly dominates z. More formally, the hypervolume indicator I H is an unary quality indicator such that I H (A, z) = Z dom(A, z)dz where dom(A, z) = {z ∈ Z : ∃z ∈ A : z z z}.

In the present work we use the hypervolume difference indicator I - H [Zitzler, 1999] (to be minimized). Given an approximation set A and the reference point z, the indicator value is defined as:

I - H (A, Y nd , z) = I H ( Y nd , z) -I H (A, z)
I - H (A, Y nd , z) defines the hypervolume of the subspace that is weakly dominated by Y nd but not by A (see Figure 2.2). In contrast to the original hypervolume indicator, the lower I - H (A), the better the quality of A is. The computation of hypervolume is time consuming, particularly when the sets are large and the number of objectives is high. Therefore, we utilize two publicly available and efficient algorithms, each one being the best known method for computing hypervolume for a particular range of p. For p ≤ 4, we use the algorithm of Fonseca et al. [START_REF] Fonseca | An improved dimensionsweep algorithm for the hypervolume indicator[END_REF], Beume et al., 2009] 1 . For p ≥ 5, we use instead the Walking Fish Group algorithm [START_REF] While | A fast way of calculating exact hypervolumes[END_REF] 2 . z

• • • • • • • • f 1 f 2 Figure 2
.2 -Hypervolume difference I - H (gray area) between the approximation of the efficient set Y nd (black dots) and an approximation set A (red dots) given a reference point z.

Before using I -

H , a normalization is necessary in order to allow the different objectives to contribute equally to indicator value. A standard linear normalization procedure will apply the following transformation: are respectively the estimated minimum and maximum values that the j th objective can take, for each j = 1, ..., p. The computation of z min j and z max j is based on the values of the points of all provided approximation sets. Note that without the +1 in (2.1), extreme points will not contribute to the hypervolume value. After normalization, the coordinates of points fall in the range [1,2].

As advised by [START_REF] Fonseca | An improved dimensionsweep algorithm for the hypervolume indicator[END_REF], Beume et al., 2009] in their hypervolume computation algorithm, we use z = z max + 0.1 × (z max -z min ) as the reference point for computing the hypervolume. After the normalization step, z = (2.1, ..., 2.1).

Epsilon indicator

Given an approximation set A and the approximation of the non-dominated set Y nd , the indicator I [START_REF] Zitzler | Performance assessment of multiobjective optimizers: an analysis and review[END_REF] (to be minimized) gives the smallest factor * ≥ 0 by which A is worse than Y nd with respect to all objectives, defined as:

I (A, Y nd ) = inf ∈R {∀z ∈ Y nd , ∃z ∈ A : z j z j }
The lower I (A, Y nd ), the better the approximation set A comparing to Y nd .

R2 indicator

Given an approximation set A and a set of weights Λ, the R2 indicator I R2 [START_REF] Hansen | Evaluating the quality of approximations to the non-dominated set[END_REF] (to be minimized) value of A is defined as:

I R2 (A, Λ, Y nd , z * ) = λ∈Λ min x∈A wat(x, λ, z * ) -min x∈ Y nd wat(x, λ, z * )

|Λ|

where wat is the weighted augmented Tchebychev function defined in (1.3). The lower I R2 (A, Λ, Y nd , z * ), the better the approximation set A is comparing to Y nd . As indicated in [START_REF] Fonseca | A tutorial on the performance assessment of stochastic multiobjective optimizers[END_REF], the set Λ is defined using the MDW method with a parameter D which should be sufficiently large to cover well

Y nd . Figure (2.3) illustrates I R2 . λ 1 λ 2 λ 3 λ 4 λ 5 z * • • • • • • • • f 1 f 2 Figure 2.
3 -Representation in Z of the set of weights Λ used to compute the I R2 value of an approximation set A (red dots), given the approximation of the efficient set Y nd (black dots) and the approximation of the ideal point z * (p = 2).

In order to have a number of weights proportional to the size of Y nd , we set

D := arg inf{( D +p-1 p-1 ) ≥ 1 10 | Y nd | : D ∈ N}.
As suggested by Fonseca et al. [START_REF] Fonseca | A tutorial on the performance assessment of stochastic multiobjective optimizers[END_REF], normalization is not mandatory for this indicator.

For all presented indicators, the value of the approximation of the non-dominated set Y nd is 0.

Mann-Whitney statistical test

In order to statistically compare the results of the different algorithms which will be tested in this document, the Mann-Whitney non-parametric statistical test [START_REF] Mann | On a test of whether one of two random variables is stochastically larger than the other[END_REF] is applied. For a specific indicator on a given instance, this test assesses whether two algorithms are comparable. If the Mann-Whitney test is satisfied, it means there is no statistical difference between the values of the quality indicator obtained by the two algorithms. Otherwise mean values are simply compared.

As three hypotheses are tested simultaneously (one for each indicator I - H , I , I R2 ) given an instance, the levels of risk of the tests have been adjusted with the Holm sequential rejective method (see [Holm, 1979] for more details). The starting level of risk of the Mann-Whitney test is fixed to 1%.

MO meta-heuristics

We can categorize the meta-heuristics into four main classes which are of particular interest in this thesis: nature-inspired meta-heuristics [START_REF] Barán | A multiobjective ant colony system for vehicle routing problem with time windows[END_REF],López-Ibáñez and Stützle, 2012,Xue et al., 2013], MO evolutionary algorithms [START_REF] Coello | Evolutionary algorithms for solving multi-objective problems[END_REF], MO local search [START_REF] Ulungu | Heuristic for multiobjective combinatorial optimization problems with simulated annealing[END_REF], Hansen, 1997, Talbi et al., 2001, Paquete et al., 2004, Vianna and Arroyo, 2004, Drugan and Thierens, 2010], and MO Monte Carlo Search [START_REF] Wang | Multi-objective monte-carlo tree search[END_REF]. Most of the presented meta-heuristics are said population-based, as they manages simultaneously a set of solutions (called a population) instead of a single solution.

In general, a meta-heuristic maintains a number of archives. An archive is a set of incomparable solutions. In particular, the global archive is the best-so-far approximation of the efficient set, i.e. the archive of all incomparable solutions found so far by the meta-heuristic.

This section focuses on meta-heuristics introducing important notions or having inspired the new methods presented in this document. The level of detail allowed for a method depends both on its recency and its relevance with respect to this thesis. We refer the reader to [START_REF] Ehrgott | Approximative solution methods for multiobjective combinatorial optimization[END_REF], Ehrgott and Gandibleux, 2008, Talbi, 2009] for overviews of MO meta-heuristics.

Nature-inspired meta-heuristics

Ant Colony Optimization (ACO) [START_REF] Dorigo | Ant colony optimization[END_REF]] is a population-based constructive meta-heuristic, as it iteratively constructs a solution. It is inspired by the natural behavior of real ants which communicate indirectly by means of trails of a chemical substance called pheromone. For optimizing an addressed combinatorial problem, an ACO method controls a number of agents called (artificial) ants whose object consists in generating new solutions by following a stochastic construction policy. Each ant starts with an empty solution and then iteratively adds elementary components to the current partial solution until a complete solution is created. The policy uses two types of information: the pheromone information reflecting the experience accumulated by previous ants; and the heuristic information, depending on the addressed problem. The construction policy is called a learning policy in the sense that the pheromone information it uses is regularly updated in function of the solutions found by the ants (this mechanism is called reinforcement learning).

Multi-Objective ACO (MOACO) [START_REF] Barán | A multiobjective ant colony system for vehicle routing problem with time windows[END_REF]] is an extension of ACO for optimizing MOCO problems and works similarly as single-objective ACO. Generally, MOACO methods are aggregation-based in the sense that they use aggregation functions to generate new solutions (see [START_REF] López-Ibáñez | The automatic design of multiobjective ant colony optimization algorithms[END_REF] for example). MOACO methods have been applied to different MOCO problems, like MOKP [START_REF] Alaya | Ant colony optimization for multi-objective optimization problems[END_REF], MOTSP [START_REF] López-Ibáñez | The automatic design of multiobjective ant colony optimization algorithms[END_REF], MO Vehicle Routing with Time Windows [START_REF] Barán | A multiobjective ant colony system for vehicle routing problem with time windows[END_REF]] and large-scale MO Shortest Path [START_REF] Ghoseiri | An ant colony optimization algorithm for the bi-objective shortest path problem[END_REF].

Another nature-inspired meta-heuristic is the Particle Swarm Optimization (PSO) [START_REF] Kennedy | A discrete binary version of the particle swarm algorithm[END_REF], which originally mimics the behavior of a swarm of particles or animals, like bird flocks or fish schools. Instead of constructing new solutions, PSO explicitly maintains a population and iteratively improves the current solutions, called the particles (see [Kennedy, 2011] for more details on PSO). PSO has recently been adapted to MOCO [START_REF] Xue | Particle swarm optimization for feature selection in classification: A multi-objective approach[END_REF] but, to our knowledge, is not considered as a leading general method in MOCO.

As rightly pointed out by Sörensen [Sörensen, 2015], many meta-heuristics based on a metaphor of some natural or physical process have emerged in recent years and propose diverse approaches for optimizing a problem. Like Sörensen, we believe that a great majority of these meta-heuristics are only specific variants of existing ones. None of these methods will be developed.

Evolutionary Algorithms

Evolutionary Algorithm (EA) -see [START_REF] Bäck | Handbook of evolutionary computation[END_REF] for a survey of EA-is a fundamental class of populationbased meta-heuristic. In an EA, a solution is called an individual. The population of an EA is involved into an evolution process by iteratively generating and eliminating individuals, given a fitness function evaluating the generated individuals. Each iteration of a basic EA is composed of three main steps:

1. Selection of parents: a number of individuals (the parents) are selected among individuals from the population.

2. Combination of parents: the parents are combined in order to generate new individuals (called children or offspring) with a good fitness score. The children are inserted into the population.

3. Update of population: a subset of the current population is selected to compose the next population.

There are many different categories of EA, the main one is the Genetic algorithms (GA) [Goldberg, 1989, Holland, 1992] which emulate the principles of natural evolution. In a GA, several parents (often two) are combined through a crossover operator which creates a number of feasible solutions (often a single or two) by combining the elements composing the parents. Then a mutation operator is applied to each generated child, slightly modifying the individual in order to diversify the search. These operators are called genetic operators and are problem-specific.

Another interesting and more recent category of EA is Estimation of Distribution Algorithms (EDA) [START_REF] Larrañaga | Estimation of distribution algorithms: A new tool for evolutionary computation[END_REF]. Instead of using crossover and mutation operators, an EDA samples an explicit probabilistic model (like Bayesian networks) built from a selected subset of the current population.

The adaptation of EA for MOCO problems (MOEA) is quite natural. In general, a MOEA manages two populations:

• a global archive, which is the archive of all incomparable solutions found so far;

• a smaller population containing good quality solutions according to the fitness function used and welldistributed in the objective-space. This population is generally essential for generating the offspring at the current iteration.

Depending on the MOEA, different fitness functions are used to compare individuals during parent selection and population update steps. Indeed, the fitness function can be an aggregation function [Murata andIshibuchi, 1995,Zhang andLi, 2007], or dominance-based [START_REF] Deb | A fast elitist non-dominated sorting genetic algorithm for multi-objective optimisation: Nsga-ii[END_REF], Zitzler et al., 2001], or even more complex like quality indicator-based [START_REF] Zitzler | Indicator-based selection in multiobjective search[END_REF]. During the parent selection step, a number of parents are selected from the second population in order to maintain a certain degree of diversity during the combination process.

The research field of MOEA is very active: see [START_REF] Schwarz | [END_REF]Ocenasek, 2001, Pelikan et al., 2006] for typical Multi-objective EDA (MOEDA) and [START_REF] Coello | Evolutionary algorithms for solving multi-objective problems[END_REF], Zhou et al., 2011] for surveys on MOEA. But in this thesis, we are particularly interested in algorithms following the notion of decomposition [Murata et al., 2001, Zhang andLi, 2007].

Decomposition method

Murata et al. [START_REF] Murata | Specification of genetic search directions in cellular multi-objective genetic algorithms[END_REF] introduced the concept of cellular structure for MO Genetic Algorithms. This concept has been generalized and renamed Decomposition by Zhang and Li [START_REF] Zhang | MOEA/D: A multiobjective evolutionary algorithm based on decomposition[END_REF] with their MOEA based on Decomposition (MOEA/D) method. MOEA/D is an aggregation-based MOEA as it decomposes a MOCO problem into a fixed number of K aggregation functions and optimizes them simultaneously in a collaborative way. Each function is defined by a weight λ giving a unique search direction, and maintains a best-so-far solution (called an incumbent) according to the corresponding chosen aggregation function F (•, λ) (e.g. λf (•), wat(•, λ, z * ) or others) for the entire duration of the run. The weights defining the directions are well-dispersed in the weight space as they are generated through MDW.

X all ← ∅ (λ 1 , ..., λ K ) ←MDW(κ) such that K = ( κ+p-1 p-1
)

for k ← 1, ..., K do N (λ k ) ← T nearest neighbors of λ k from (λ 1 , ..., λ K ) (x 1 , ..., x K ) ←Initialization(K) repeat for k ← 1, ..., K do λ i , λ j ←RandomSelection(N (λ k )) x k ←Crossover(x i , x j ) x k ←Mutation( x k ) x k ←Improvement( x k ) for l ← 1, ..., K do if F ( x k , λ l ) < F (x l , λ l ) then x l ← x k Add( x k , X all )
until stopping criterion is met;

Let λ k ∈ R p be a weight, x k ∈ X be the incumbent related to F (•, λ k ), and π k = (λ k , x k ) be a pair denoting the k th sub-problem, for k = 1, ..., K. The neighborhood of the k th sub-problem consists of all the subproblems with a weight among the T nearest neighbors of λ k , where T is a fixed parameter. Collaboration between sub-problems is performed by optimizing neighboring sub-problems of π k to generate new solutions for π k , for k = 1, ..., K. The major motivation of MOEA/D is that collaboration between close sub-problems should improve the global optimization process.

Algorithm 1 details MOEA/D. The method maintains two populations: the global archive X all and the set of incumbents (x 1 , ..., x K ). First, sub-problems and corresponding neighborhoods are generated (lines 2-5).

Weights are generated via MDW, and the incumbents are initialized randomly or with a problem-specific heuristic. Then, starts the iterative phase (lines 6-16). At a given iteration, each sub-problem π k is considered for optimization (lines 8-11), for k = 1, ..., K. Two neighboring sub-problems of π k are randomly selected and their corresponding incumbents are recombined. The resulting offspring is mutated then improved with a problem-specific improvement heuristic, like local search (see next Section 2.2.3) for example. Because mutation may generate an unfeasible offspring, a repair heuristic may be called before improvement (or replace simply it) in order to make feasible the offspring. The improved generated individual will replace any worse incumbent x l on the aggregated problem F (•, λ l ), for each l = 1, ..., K (lines 12-14). A similar procedure is commonly used, the AddAll procedure. It consists in presenting one by one each solution of a solution set (first parameter) to an archive (second parameter) and updating accordingly the archive. It returns the updated archive.

if x ∈ X : f (x ) f (x) then X dom ← {x ∈ X : f (x) ≤ f (x )} X ← X \ X dom X ← X ∪ {x}
Despite its simplicity, MOEA/D generally obtains better results on MOCO problems than the most widely used MOEA called NSGAII (see [START_REF] Li | Multiobjective optimization problems with complicated pareto sets, moea/d and nsga-ii[END_REF]) and has been regularly improved (see [START_REF] Chen | Enhancing moea/d with guided mutation and priority update for multi-objective optimization[END_REF], Zhao et al., 2012]); in particular, a recent modification proposes an adaptive adjustment of the weights in order to better fit to the shape of complex non-dominated sets [START_REF] Qi | Moea/d with adaptive weight adjustment[END_REF]. MOEA/D has been applied to different MOCO problems but does not produce sufficiently good results to be considered as a state-of-the-art MOCO optimization method [START_REF] Chang | Moea/d for flowshop scheduling problems[END_REF], Ke et al., 2013]. By contrast, our concern about MOEA/D is its ability to obtain a well-diversified population thanks to the sub-problems mechanism.

Local search

Local search (LS) is a fundamental optimization methodology and is nowadays a key component of many state-of-the-art meta-heuristics for optimizing MOCO. Local search algorithms aim at iteratively modifying a solution (or a set of solutions) in order to improve it. In this section, we first introduce basic notions of LS, then present some well-known LS methods, and finally focus on LS methods used in this thesis.

Basic notions of LS

Let d : (X, X) → N + be a distance measure between two feasible solutions. For any k ≥ 1, we define a k-neighborhood structure

N k : X → 2 X such that N k (x) = {x ∈ X : d(x, x ) = k}. Changing from x ∈ X to one of its neighbors x ∈ N k (x) is called a neighborhood move.
Given a (single-objective or MO) combinatorial problem, a fitness function F : X → R to be minimized and a neighborhood structure N k , a local search descent explores, at each step, the neighborhood of the current solution x ∈ X so as to find a neighbor x ∈ N k (x) such that F (x ) < F (x). There exist two main exploration neighborhood strategies of the neighborhood structure N k from the current solution:

• either the exploration of the neighborhood is stopped at the first neighbor improving the fitness (first improvement strategy);

• or the neighborhood is completely explored (best improvement or complete exploration strategy).

At the end, a LS descent stops in a local optimum w.r.t. N k , for which no improving neighbor can be found.

A Variable Neighborhood Descent (VND) [START_REF] Brimberg | Improvements and comparison of heuristics for solving the uncapacitated multisource weber problem[END_REF] is a LS descent which explores different neighborhood structures in a deterministic order. We consider the simplest form of VND which explores a limited number of neighborhood N j of increasing size j = 1, 2, ..., k (s.t. initially j = 1). Globally, the idea of VND is to explore like LS descent the neighborhood of the current solution with the neighborhood of smallest possible size while an improving solution is found. Once we are stuck into a local optimum according to the current neighborhood structure, we increase its size to escape from the local optimum. More precisely, at each step of the descent, once a neighborhood N j has been explored from a current solution x ∈ X:

• if an improving neighbor x ∈ N j (x) has been found, then VND switches to x and reset j to 1.

• otherwise, VND increases the size j of the neighborhood. If j exceeds k, then the method terminates.

Upon termination, the current solution is locally optimal w.r.t. all neighborhoods N j , j = 1, ..., k. The key idea of the VND presented above is to prioritize the search of an improvement into the smallest possible neighborhood.

Stochastic local search (SLS) [START_REF] Hoos | Stochastic local search: Foundations and applications[END_REF]] is a general concept of local search algorithm restarting the local search descent by use of a stochastic process.

A perturbation move (also called kick), is a technique with the aim of escaping from a local optimum. Let x ∈ X be a local optimum according to N k (k ≥ 1). A perturbation consists in applying a random move from x in a larger size neighborhood N l (l > k). The perturbation neighborhood size l has to be sufficiently large to lead to a different attraction basin than the one induced by N k from x. An Iterated Local Search (ILS) algorithm [START_REF] Lourenço | Iterated local search[END_REF]] is a SLS. It builds a sequence of locally optimal solutions by iteratively applying a perturbation to the current locally optimal solution and restarting a local search descent from this modified solution. Figure 2.4 illustrates the mechanism of ILS.

Let us now present a number of important LS meta-heuristics and their adaptation to MOCO.

Simulated Annealing

Simulated Annealing (SA) [START_REF] Kirkpatrick | Optimization by simulated annealing[END_REF]] is a meta-heuristic inspired from a technique consisting in cooling a material down at a controlled rate, altering its physical properties and making it more resistant at the end of the process. Given a fitness to optimize and a neighborhood function, SA originally manages a single solution. At each iteration, the method randomly selects a neighbor of the current solution, then decides to move to the neighbor by following a stochastic acceptance rule (generally the Metropolis-Hastings rule [Hastings, 1970]). This rule encourages the quality improvement between the current solution and the neighbor, and makes acceptance of a worse neighbor harder over time with a mechanism called temperature cooling.

Different MO versions of SA have emerged. To our knowledge, all versions use an aggregation function as fitness function, the weighted-sum in a great majority of cases. As MO methods, they manage an archive.

The main difference between the versions comes from the choice of the weight(s) used for aggregating the objectives and providing direction(s) to the search.

Ulungu and Teghem's MOSA [START_REF] Ulungu | Heuristic for multiobjective combinatorial optimization problems with simulated annealing[END_REF]] and Serafini's MOSA [Serafini, 1994] follow the same scheme than the original SA. In order to approximate an efficient set, both methods are applied several times with different weights. By contrast, PSA [START_REF] Czyzżak | Pareto simulated annealing -a metaheuristic technique for multiple-objective combinatorial optimization[END_REF] and EMOSA [START_REF] Li | An adaptive evolutionary multi-objective approach based on simulated annealing[END_REF] are population-based methods as they manage simultaneously a number of weights and their respective incumbents.

In particular, EMOSA proposes a very similar framework as MOEA/D, the main differences come from the fact that genetic operators are replaced by SA and weights may be replaced by similar ones under certain conditions, in order to diversify the search directions during the run. EMOSA has been compared to Ulungu and Teghem's MOSA, Serafini's MOSA and PSA and obtains better results on the MOKP and MOTSP tested instances.

Tabu Search

Tabu Search (TS) [Glover, 1989] is a meta-heuristic that escapes from local optima by forbidding (moves to) solutions recently visited. These moves or solutions are memorized into a memory structure called tabu list. Given a fitness to optimize and a neighborhood function, TS originally manages a single solution. At each iteration, the best non-tabu neighbor of the current solution is selected, then the tabu list is updated with the move/solution, finally the method moves to the neighbor. Different data structures can be used to memorize information in the tabu list. If the addressed problem instance has a large decision space and fast look-ups are required, one can use a hash table with Zobrist [Zobrist, 1970] or Woodruff and Zemel [START_REF] Woodruff | Hashing vectors for tabu search[END_REF] hashing functions.

Concerning the adaptation of TS to MOCO, different methods propose a general framework: MOTS [START_REF] Gandibleux | A tabu search procedure to solve multiobjective combinatorial optimization problems[END_REF], Hansen, 1997], TAMOCO [Hansen, 2000] and MOTAS [START_REF] Loukil | Solving multi-objective production scheduling problems using metaheuristics[END_REF]. To our knowledge, all versions use the (augmented) weighted Tchebychev function as fitness function and apply a number of TS runs with different weights.

Greedy Randomized Adaptive Search Procedure

Greedy Randomized Adaptive Search Procedure (GRASP) [START_REF] Feo | A probabilistic heuristic for a computationally difficult set covering problem[END_REF]] is an iterative metaheuristic combining two algorithmic aspects. Let F : X → R be a fitness optimized by GRASP. At each iteration, GRASP first constructs an initial solution through a randomized constructive procedure, then conducts from this solution a local search descent using a neighborhood function, finally updates the bestso-far solution given F . At each step of the construction procedure, an element is selected uniformly at random from a candidate list, then added to the partial solution.

About the adaptation to MOCO, the research field of MO GRASP is pretty active and proposes different frameworks. To our knowledge, the first adaptation of GRASP to MOCO is proposed by [START_REF] Gandibleux | A first making use of grasp for solving moco problems[END_REF]. Recently, in [START_REF] Martí | Multiobjective grasp with path relinking[END_REF], the authors made a survey and a classification of MO GRASP. A large majority follow the same scheme as the original GRASP and use the weighted-sum as fitness function. Like in SA, a number of MO GRASP (such as [START_REF] Vianna | A grasp algorithm for the multiobjective knapsack problem[END_REF]) first generate several weights, then optimize the related aggregation functions with GRASP. Other MO GRASP algorithms (such as [START_REF] Li | An elitist grasp metaheuristic for the multiobjective quadratic assignment problem[END_REF]) are population-based as they manage simultaneously a number of weights, optimize the related aggregation functions and memorize their respective incumbents.

Pareto Local Search

Pareto Local Search (PLS) [START_REF] Talbi | A hybrid evolutionary approach for multicriteria optimization problems: Application to the flow shop[END_REF], Paquete et al., 2004] is the MO extension of LS descent. Given a neighborhood function N k , PLS is an iterative population-based meta-heuristic starting from a set of solutions X. At each iteration, a number of unexplored solutions are selected from X then extracted and transferred into a temporary set, finally for each selected solution x ∈ X, N k (x) is explored such that all neighbors not dominated by any solution found so far are accepted and inserted into X. PLS stops once all solutions from X have been visited and is stuck in a locally efficient set with respect to N k , i.e. a set of solutions such that all neighbors are weakly dominated by at least one solution found so far.

Two similar versions of PLS have emerged: the so-called Talbi et al. PLS [START_REF] Talbi | A hybrid evolutionary approach for multicriteria optimization problems: Application to the flow shop[END_REF] and Paquete et al. PLS [START_REF] Paquete | Pareto local optimum sets in the biobjective traveling salesman problem: An experimental study[END_REF]. Note that related approaches to Paquete et al. PLS can be originally found in [Hamacher andRuhe, 1994, Andersen et al., 1996] for the bi-objective Spanning Tree Problem only, in [START_REF] Gandibleux | The supported solutions used as a genetic information in a population heuristics[END_REF] where only a single iteration is performed and employed for bi-objective Permutation Scheduling and 0-1 Knapsack Problems, and finally in [START_REF] Ehrgott | Approximative solution methods for multiobjective combinatorial optimization[END_REF], where a more general framework is detailed. In [START_REF] Liefooghe | On dominance-based multiobjective local search: design, implementation and experimental analysis on scheduling and traveling salesman problems[END_REF], the authors propose a common framework and identify two important components in PLS:

• the selection strategy, defining how many solutions are selected (then extracted) from X

• the exploration neighborhood strategy, defining how the neighborhood N k (x) of a selected solution x is explored (as in single-objective LS descent)

Two selection strategies have been proposed: either a single solution is extracted from X (Paquete et al. PLS), or all solutions from X are extracted (Talbi et al. PLS).

Algorithme 3 : PLS

Input : neighborhood structure N k , boolean first-dominating, set of solutions to explore X, global archive X all Output : X all X all ←AddAll( X, X all ) while X = ∅ do X new ←PLS-iteration( N k , first-dominating, X, X all ) X ← X new return X all
There is no major differences in terms of quality of approximation obtained by these two different strategies, as experimentally shown by [START_REF] Liefooghe | On dominance-based multiobjective local search: design, implementation and experimental analysis on scheduling and traveling salesman problems[END_REF] on MOTSP and MO Permutation Flowshop Scheduling Problem, and by [START_REF] Lust | Two-phase pareto local search for the biobjective traveling salesman problem[END_REF] on bi-objective TSP. Anyway, it is important to remark that any solution stored in the temporary set at a given iteration is still explored even if a newly generated solution dominates it. We say that solutions stored in the temporary set are protected. Consequently, in Paquete et al. PLS, only the currently explored solution is protected, thus any other dominated solution is immediately deleted and thus, never explored. On the other hand,

X new ← ∅ foreach x ∈ X do foreach x ∈ N • (x) do if f (x) f (x ) then if Add(x , X all ) then Add(x , X new ) if first-dominating and f (x ) ≤ f (x) then break return X new
Concerning the exploration neighborhood strategy, both [START_REF] Liefooghe | On dominance-based multiobjective local search: design, implementation and experimental analysis on scheduling and traveling salesman problems[END_REF] and [START_REF] Drugan | Stochastic pareto local search: Pareto neighbourhood exploration and perturbation strategies[END_REF] propose two interesting strategies to explore N k (x) of a current solution x:

• either the exploration of N k (x) is stopped at the first neighbor dominating x (first dominating neighbor strategy);

• or N k (x) is completely explored (complete exploration strategy).

Note that two other exploration strategies have been proposed in [START_REF] Liefooghe | On dominance-based multiobjective local search: design, implementation and experimental analysis on scheduling and traveling salesman problems[END_REF] and [START_REF] Drugan | Stochastic pareto local search: Pareto neighbourhood exploration and perturbation strategies[END_REF] but Drugan and Thierens [START_REF] Drugan | Stochastic pareto local search: Pareto neighbourhood exploration and perturbation strategies[END_REF] proved that these strategies stop prematurely, thus we do not consider them.

These two studies have concluded that the first dominating neighbor strategy is more efficient than the complete exploration strategy when the computational resources (time or number of iterations) are limited.

Algorithm 3 describes PLS and Algorithm 4 details the core of a PLS iteration. PLS takes as input parameters a neighborhood structure N k , a boolean first-dominating fixed to true if and only if the first dominating neighbor strategy is chosen, a set of solutions X to explore; finally the global archive X all , memorizing all incomparable solutions found so far. PLS returns X all .

At each iteration (Algorithm 4), PLS explores the neighborhood of each solution x ∈ X, and retains in an auxiliary archive X new all the mutually incomparable neighbors of x not weakly dominated by any solution memorized in X all . If the first dominating neighbor strategy is activated, and once a current solution x is dominated by its neighbor, then the neighborhood exploration of x stops. Finally (cf. Algorithm 3), solutions from X new are transferred into X.

PLS continues this process until no more new non-weakly dominated neighbors have been found.

X new ← ∅ foreach x ∈ X do X local ← ∅ foreach x ∈ N • (x) do if f (x) f (x ) then Add(x , X local ) if first-dominating and f (x ) ≤ f (x) then break foreach x ∈ X local do if Add(x , X all ) then Add(x , X new )
return X new Some remarks can be made on this algorithm. First, the use of the auxiliary set X new prevents the exploration of the neighborhood of an already visited solution. Second, the generated solutions (thus the final set X all ) do not depend on the order according to which the solutions of X are examined. Finally, passing X all as input parameter allows PLS to consider as global archive an external archive from a higher level method using PLS as a component.

In [START_REF] Jaszkiewicz | Nd-tree: a fast online algorithm for updating a pareto archive and its application in many-objective pareto local search[END_REF], the authors propose to slightly modify the original PLS by using an additional archive, called here local archive (Algorithm 3 using Algorithm 5 at each iteration). In fact, instead of directly presenting each generated solution to the global archive X all (which can be computationally costly as X all might be large), they use a local archive X local (generally much smaller) which memorizes only the mutually incomparable neighbors of the current solution x. Like in the original version, if the first dominating neighbor strategy is activated, and once a current solution x is dominated by its neighbor, then the neighborhood exploration of x is stopped. Then, all solutions from X local are presented to the auxiliary set X new .

It is important to note that both sub-versions of PLS (with or without local archive) generate the same solutions and thus provide the same final set X all .

PLS has been applied to different problems like MOTSP [START_REF] Paquete | Pareto local optimum sets in the biobjective traveling salesman problem: An experimental study[END_REF],Liefooghe et al., 2012,Dubois-Lacoste et al., 2012], MO Flowshop Scheduling Problem (MOFSP) [START_REF] Liefooghe | On dominance-based multiobjective local search: design, implementation and experimental analysis on scheduling and traveling salesman problems[END_REF], MO Quadratic Assignment Problem (MOQAP) [Paquete and Stützle, 2009a]. In [START_REF] Dubois-Lacoste | Anytime pareto local search[END_REF], the authors propose additional algorithmic components for PLS in order to enhance its anytime behavior.

In [START_REF] Lust | Variable and large neighborhood search to solve the multiobjective set covering problem[END_REF], the authors propose a PLS applying the concept of VND (Algorithm 6), and we call it PLS-VND. PLS-VND has the same parameters than PLS except that it uses a number k ≥ 1 of distinct neighborhood structures N 1 , ..., N k . Globally, the idea of PLS-VND is to explore like PLS the neighborhood of the current set with the neighborhood structure of smallest possible size while new solutions are found. Once we are stuck into a locally efficient set with respect to the current neighborhood structure, we increase its size to escape from the attraction basin.

Algorithme 6 : PLS-VND Input : set of neighborhood structures (N 1 , ..., N k ), boolean first-dominating, set of solutions to explore X, global archive X all Output : X all X all ←AddAll( X, X all ) j ← 1 while j ≤ k do while X = ∅ do

X new ←PLS-iteration( N j , first-dominating, X, X all ) foreach x ∈ X do j(x) = j; if X new = ∅ then j ← 1 X ← X new j ← j + 1 X ← {x ∈ X all : j(x) < j} return X all
More precisely, a label j(x) ≥ 1 is associated to each x ∈ X all and gives the maximal size of the neighborhood that has been explored from x. This label avoids to explore the neighborhood of a solution if it has already been explored before. Let j be the neighborhood structure size currently considered, initially set to 1.

At each iteration of PLS-VND, the neighborhood of each solution from X is explored using N j , and X all is updated with all newly found solutions memorized into X new (lines 5-6). Then:

• If some new solutions are effectively found (X new = ∅), then we aim at exploring their neighborhood.

Besides, a solution locally optimal for N j is not necessarily locally optimal for N i , i < j. Thus we reset the neighborhood structure to N 1 , set the current set X to X new , and continue the exploration with X (lines 7-9).

• Otherwise X new = ∅, so all solutions from X all are locally optimal according to N j . Thus the neighborhood structure size j currently considered is increased (line 10) and X is set with all solutions from X all for which the neighborhood has not already been explored with N j , N j+1 , ..., N k (line 11).

PLS-VND stops once the neighborhood of all solutions from X all has been explored with N 1 , ..., N k . Obviously, PLS-VND is a generalization of PLS such that PLS corresponds to PLS-VND with a single neighborhood structure. It is quite recent and to our knowledge, it has only been applied to the MO Set Covering Problem by [START_REF] Lust | Variable and large neighborhood search to solve the multiobjective set covering problem[END_REF].

The generation process of the initial set of solutions to explore is crucial for PLS. Indeed, as experimentally shown in [START_REF] Lust | Two-phase pareto local search for the biobjective traveling salesman problem[END_REF] and [Dubois-Lacoste et al., 2011a], with an initial set of poor quality, such as a number of randomly generated solutions (like in [START_REF] Paquete | Pareto local optimum sets in the biobjective traveling salesman problem: An experimental study[END_REF], Drugan and Thierens, 2010,Liefooghe et al., 2012] among others), PLS converges slowly towards the non-dominated set and provides poor results. The next section discusses about a crucial notion to improve PLS.

2-Phase Pareto Local Search

Originally, the exact 2-phase method [Ulungu andTeghem, 1995, Przybylski et al., 2010b] is an exact algorithm with the following principle: phase one finds the extreme supported non-dominated points, and phase two the non-extreme and non-supported ones.

The key idea of the first phase is that any supported non-dominated point can be found by solving a weighted sum problem with an appropriate weight. Thus the first phase consists in generating a number of appropriate weights then solving the related weighted sum problems with a single-objective exact solver. When the singleobjective version of the addressed MOCO is polynomially solvable, like Assignment Problem or Shortest Path Problem for example, this task becomes easy. The solver optimizing each weighted sum problem is problemdependent, contrary to the weight generation procedure. Initially designed for the bi-objective case [Cohon, 1978, Aneja andNair, 1979], different methods to generate the extreme supported non-dominated points are proposed nowadays [Przybylski et al., 2010a, Özpeynirci and Köksalan, 2010, Bökler and Mutzel, 2015].

Except in the bi-objective case, all these methods remain complex to implement and difficult to use in practice.

The second phase is problem-dependent and computationally harder because single-objective exact solvers are no longer sufficient to find non-supported non-dominated points, without adding additional constraints to the original problem, like, for example, the -constraint [START_REF] Haimes | Bicriterion formulation of problems of integrated system identification and system optimization[END_REF]] method does.

Originally based on their previous work [Gandibleux et al., 1998a], [START_REF] Gandibleux | The supported solutions used as a genetic information in a population heuristics[END_REF] have been the first, to our knowledge, to propose a hybrid 2-phase method mixing exact and approximation methodologies for bi-objective problems. In particular, the 2-phase framework they proposed first finds either the exact or an approximation of a reduced supported efficient solution set by following the dichotomic scheme [Cohon, 1978, Aneja andNair, 1979], then applies in second phase a memetic algorithm employing a single iteration of PLS. They tested their method on bi-objective Permutation Scheduling and 0-1 Knapsack Problems.

2-Phase PLS is a heuristic adaptation of the exact 2-phase method and introduced by two different groups of authors: Lust and Teghem [START_REF] Lust | Two-phase pareto local search for the biobjective traveling salesman problem[END_REF] with 2PPLS ("2-Phase PLS"), and Dubois et al. [Dubois-Lacoste et al., 2011a] with TP+PLS ("Two-Phase PLS") Both methods globally follow the same scheme:

• The first phase generates a number of well-diversified weights, then optimize the corresponding weighted sum problems through an effective single-objective problem-specific heuristic, in order to quickly approximate the non-dominated supported set. The diversification of the weights (in the weight space) is fundamental as it allows the generation of an approximation covering well the non-dominated set. In such a case, we say that the generated points are well dispersed along the non-dominated set. Besides, the efficiency of the selected solver (often problem-specific) is mandatory to generate good quality points towards the non-dominated set.

• The second phase refines the approximation of the non-dominated set with PLS(-VND).

In 2-Phase PLS, the first phase uses much simpler weight generation procedures than in the exact case.

Originally, [START_REF] Lust | Two-phase pareto local search for the biobjective traveling salesman problem[END_REF] uses an approximation version of the dichotomic scheme [Cohon, 1978, Aneja andNair, 1979] for the bi-objective case, but nowadays MDW is preferred as it works for any number of objectives.

In [START_REF] Lust | Two-phase pareto local search for the biobjective traveling salesman problem[END_REF] and [Dubois-Lacoste et al., 2011a], the authors show that the speed convergence and the quality result of PLS is greatly improved by initializing the starting set of PLS with such a good quality approximation of the non-dominated supported set. 2-Phase PLS rapidly became state-of-the-art methods on different and hard MOCO problems such as MOTSP [START_REF] Lust | Two-phase pareto local search for the biobjective traveling salesman problem[END_REF], MO Multidimensional KP [START_REF] Lust | The multiobjective multidimensional knapsack problem: a survey and a new approach[END_REF]

X all ← ∅ // Phase 2: X all ←PLS-VND((N 1 , ..., N k ), first-dominating, X init , X all ) return X all
Algorithm 7 describes the general framework of 2-Phase PLS. The method takes as input parameters: a weight generation strategy (generally MDW) to generate the weights during the first phase, a single-objective solver to optimize the weighted-sum problems produced by the first phase, a set of neighborhood structures (N 1 , ..., N k ) and finally the usual possibility of first-dominating strategy for PLS(-VND).

Iterated Pareto Local Search

A large disadvantage of PLS(-VND) (and 2-Phase PLS) is that it always ends up by being stuck into a locally efficient set. To prevent this drawback and allow PLS(-VND) to escape from a locally efficient set, ILS for MOCO called Iterated PLS (IPLS) [START_REF] Drugan | Path-guided mutation for stochastic pareto local search algorithms[END_REF] have been developed. At each iteration, IPLS first forms a new set of perturbed solutions from the best-so-far approximation set, then performs PLS(-VND) from this set.

Algorithme 8 : IPLS Input : stopping criterion, set of neighborhood structures (N 1 , ..., N k ), boolean first-dominating, boolean independent-pls Output : global archive X all X init ←Initialization()

X all ← ∅ X all ←PLS-VND( (N 1 , ..., N k ), first-dominating, X init , X all ) repeat X select ←SubsetSelection( X all ) X perturb ←SubsetPerturbation( X select ) if independent-pls then X new ←PLS-VND( (N 1 , ..., N k ), first-dominating, X perturb , ∅) else X new ←PLS-VND( (N 1 , ..., N k ), first-dominating, X perturb , X all ) X all ←AddAll( X new , X all ) until stopping criterion is met; return X all
We propose a general framework of IPLS depicted in Algorithm 8. IPLS has the same parameters as PLS-VND with the addition of a stopping criterion (a maximum time or number of iterations for example) and a boolean independent-pls set to true if and only if PLS-VND is in independent mod.

First, IPLS builds an initial set of solutions X init . PLS-VND is applied on X init and initializes the global archive X all . Then at each iteration:

• a subset X select of solutions is selected from X all ;

• a number of solutions from X select are perturbed (with for example, genetic operators or LS perturbation moves), then inserted into the set X perturb ;

• a PLS-VND is conducted from X perturb , and X all is updated with all newly generated solutions memorized in X new . In addition to the first dominating strategy, PLS-VND offers the possibility to be in independent mod or not. If independent mod is activated, PLS-VND ignores the global archive X all by not passing it as input parameter (line 8). Otherwise, X all is passed as input parameter. When independent mod is activated, PLS-VND explores a largest portion of the decision space, at the cost of a greater computational effort than if independent mod is deactivated.

IPLS stops once the stopping criterion is met and finally returns X all .

To our knowledge, Drugan and Thierens [Drugan andThierens, 2010, Drugan and[START_REF] Drugan | [END_REF] first propose an IPLS and test different versions of the method on MOQAP. In their IPLS, the initialization consists in running several PLS from randomly generated solutions; at each iteration, a single solution is selected then perturbed with mutation and crossover; they use PLS in independent mod and test it with and without first dominating strategy.

Hybrid meta-heuristics

A hybrid meta-heuristic is a method combining different algorithmic components coming from different metaheuristics. By combining the qualities of different meta-heuristics, superior results are generally obtained compared to the original methods from which they are based on. Maybe the most popular hybridization scheme consists in combining genetic operators with local search, introducing the concept of memetic algorithms [Moscato, 1989]. Hybrid meta-heuristics is a large field of research and we refer the reader to [START_REF] Ehrgott | Hybrid metaheuristics for multiobjective combinatorial optimization[END_REF] about the multiple hybrid meta-heuristics developed for MOCO.

Due to recent successes of local search on hard MOCO problems [START_REF] Dubois-Lacoste | Combining two search paradigms for multi-objective optimization: Two-phase and pareto local search[END_REF], Ke et al., 2014[START_REF] Lust | Variable and large neighborhood search to solve the multiobjective set covering problem[END_REF], we are particularly concerned in hybridization implying local search only. In particular, the Multi-Objective Memetic Algorithm based on Decomposition (MoMad) [START_REF] Ke | A simple yet efficient multiobjective combinatorial optimization method using decompostion and pareto local search[END_REF] developed quite recently obtains remarkable results on some classical MOCO problems. The method combines the principle of Decomposition of MOEA/D with PLS. As a decomposition method, MoMad decomposes a MOCO problem into a fixed number of weighted sum problems and optimizes them simultaneously in a collaborative way. At each iteration, the newly generated solutions form a starting set for PLS.

Algorithm 9 describes MoMad. The method takes as input parameters a stopping criterion, a single-objective solver used during initialization, a decomposition parameter controlling the number of weights generated by MDW during initialization, and a neighborhood structure for PLS.

The initialization of MoMad (cf. Algorithm 10) is similar to the initialization of MOEA/D: a number of weights is produced with MDW and to each weight λ is assigned an incumbent x ∈ X created through the optimization of the weighted sum problem λf (•) by the single-objective optimizer. Each pair (λ, x) is inserted into the set of all sub-problems Π, and the global archive X all is updated with all generated incumbents. The initialization returns Π and X all . Then (cf. Algorithm 9), the current starting set of PLS X pls is initialized with X all .

Each iteration of the main loop is composed of two steps:

X all ← ∅ Λ ←MDW(D) Π ← ∅ foreach λ ∈ Λ do x ←Solve(λf (•), single-objective optimizer) Π ← Π (λ, x) Add(x, X all ) return (Π, X all )
• PLS step (lines 4-5 of Algorithm 9): a PLS is conducted from X pls . During this PLS, the incumbents of Π are updated with the newly generated solutions in the following way: a new solution x replaces at most one single incumbent of a sub-problem π = (λ, x) ∈ Π if λf (x ) < λf (x). After PLS, X pls is reset.

• Perturbation step (lines 6-11 of Algorithm 9): for each sub-problem π = (λ, x) ∈ Π, the incumbent is first perturbed, then a local search descent optimizing λf (•) is applied from the perturbed solution.

The optimized solution updates Π, X pls and X all . This perturbation step aims at generating a new starting set X pls for the PLS run of the next iteration.

Although not defined as such by the authors [START_REF] Ke | A simple yet efficient multiobjective combinatorial optimization method using decompostion and pareto local search[END_REF], it is interesting to see that MoMad is an IPLS and falls indeed in the framework we have introduced in the previous section.

To our knowledge, MoMad is one of the most competitive meta-heuristics as it is the current state-of-the-art method for bi-objective TSP and MO Multidimensional KP [START_REF] Ke | A simple yet efficient multiobjective combinatorial optimization method using decompostion and pareto local search[END_REF].

Monte Carlo Search

This section presents Monte Carlo Search. We first discuss about basic notions of Monte Carlo Search, then present a key Monte Carlo Search method and its MO version, and finally make a focus on the method used in this thesis. Exceptionally, we consider in this section only, that objective(s) have to be maximized, in order to be consistent with some important formulas presented below.

Basic notions of Monte Carlo Search

Monte Carlo Search is a class of stochastic search algorithms for optimizing sequential problems, i.e. problems that can be represented as tree of sequential decisions. Over the last few years, Monte Carlo Search had a profound impact on many different domains of Artificial Intelligence, particularly on single/multi-player games on combinatorial or even continuous decision spaces. In addition, the Monte Carlo Search research community is particularly active and we refer the reader to the essential survey work of Browne et al. [START_REF] Browne | A survey of monte carlo tree search methods[END_REF] on this domain.

From this thesis perspective, we are only concerned by single-player combinatorial problems with perfect information and non-stochastic transition model. Such a problem can be expressed by:

• A set of states S ⊂ 2 E = {0, 1} q . A state s ∈ S corresponds to a partial feasible solution of the addressed problem. We note s 0 ∈ S the initial state such that s 0 = {}, and S term ⊂ S the set of all terminal states. A terminal state respecting the constraints of the addressed problem corresponds to a feasible solution x ∈ X. For example, for KP, a state could be a feasible knapsack containing some items. Concerning AP, a state could be a feasible assignment of some people to some machines, and a path for TSP.

• A set of actions A. An action a ∈ A is an operation on a state s ∈ S adding and/or removing some elements e ∈ E from s. For example, an action for KP could be the operation of adding or removing a number of items from a knapsack. Concerning AP, an action could be the act of (un)assigning a number of people to machines; and for TSP, the insertion/deletion of a valid edge in a path.

• A transition function t : S × A → S. Given a state s ∈ S and an action a ∈ A, the transition function applies a on s, leading to a new state.

• A reward function F : X → R to maximize.

The search space of a sequential combinatorial problem can be represented as a tree or a directed acyclic graph, whose nodes correspond to states and directed edges to actions leading to subsequent states. The root represents the initial state, and leaves of the tree correspond to terminal states. The exploration of the tree is performed by the transition function t. This type of tree is called a game tree.

Solving such a sequential problem consists in finding, through the exploration of the game tree, the sequence of actions starting from the initial state s 0 and leading to a terminal state (i.e. a feasible solution) x * ∈ X optimizing F . Therefore, the aim of a method optimizing such a problem is to iteratively select an action from a current state to finally reach the optimal solution x * .

Let a random simulation be a sequence of actions selected via a (possibly biased) stochastic process called policy. A random simulation begins from any state and leads to a terminal state (i.e. a feasible solution).

The reward associated to a random simulation is the fitness value of the terminal state reached at the end of the simulation.

Monte Carlo Search is based on the fundamental work [Abramson, 1990] which demonstrates that the average reward obtained by performing many random simulations with a uniform distribution from a given state (resp. action) evaluates well this state (resp. action). In other words, performing many random simulations is a good indicator for measuring the ability of this state (resp. action) to lead to the optimal solution x * .

Since this preliminary work, several Monte Carlo Search methods with many different versions have been proposed and still follow the same idea of guiding the search through random simulations, although random simulations currently employed generally follow more complex policies than uniform distribution.

Besides, these methods mainly differ on two major aspects:

• The random simulation policy. Different random policies are available and the choice mainly depends on the Monte Carlo Search method applied and the problem addressed. As examples of simple sampling strategies, one can consider uniform sampling, Boltzmann sampling [START_REF] Landau | Statistical physics[END_REF], epsilon greedy strategy [START_REF] Sutton | Reinforcement learning: An introduction[END_REF]] and many others. Naturally, the use of problem-specific heuristics generally enhances sampling results (see [Cazenave, 2016] for example).

• The online management of collected data. The idea is to use the data provided by the simulations to improve the simulation process for the next iterations through online reinforcement learning techniques. (2) Expansion. (3) Simulation following a random simulation policy. (4) Back-propagation.

Figure 2.5 -One iteration of the UCT approach.

Monte Carlo Tree Search

Single-objective case

Monte Carlo Tree Search (MCTS) [Coulom, 2006] is a crucial Monte Carlo Search framework. We describe the most popular method in the MCTS family, called Upper Confidence bounds applied to Trees (UCT) [START_REF] Kocsis | Bandit based monte-carlo planning[END_REF]. UCT iteratively builds a partial game tree in an asymmetric manner, associating to each node some statistics collected from random simulations. These statistics are used in return to guide the construction of the tree and reinforce the accuracy of gathered statistics. More precisely, each iteration of UCT consists in four steps [START_REF] Chaslot | Monte-carlo tree search: A new framework for game ai[END_REF] (cf. Figure 2.5):

1. Selection: starting from the root, a child node selection policy called Upper Confidence Bound (UCB) [START_REF] Auer | Finite-time analysis of the multiarmed bandit problem[END_REF] is recursively applied to select from the current node the next child node to visit, and this way descends through the tree until the most urgent expandable node is reached. A node is expandable if it represents a non-terminal state and has still unvisited children. From a given node s, the selected action is the following:

arg max a∈A(s) F (s, a) N (s, a) + c × ln N (s) N (s, a)
where A(s) is the set of actions available from s, F (s, a) is the sum of rewards of random simulations obtained by choosing action a from s (in other words: F (s, a) is the sum of all rewards of terminal states attained by random simulations through the selection of action a from s). N (s, a) represents the number of times the action a was chosen from state s, N (s) counts how many times the node s was visited in the tree, and c > 0 is a constant to be defined. This formula enables a trade-off between intensification, represented by the first term, and exploration, represented by the second term. The larger c is, the more promoted the exploration will be.

2. Expansion: a node is added to expand the tree.

3. Simulation: a random simulation is run from the new node according to a random simulation policy.

Let x ∈ X be the newly generated solution.

4. Back-propagation: the simulation reward F (x) is back-propagated through each selected node s to update its statistics: F (x) is added to the sum of rewards F (s, a) related to s, and the counter N (s) is incremented.

UCT stops when a given stopping criterion is reached. The other MCTS algorithms mainly differ from UCT by using different child node selection policy and back-propagation mechanisms. A number of improvements have been developed for MCTS approaches these last years [START_REF] Browne | A survey of monte carlo tree search methods[END_REF], like Progressive Widening [Coulom, 2007] or (Generalized) Rapid Action Value Estimate [START_REF] Gelly | [END_REF]Silver, 2007, Cazenave, 2015]. Algorithms following the MCTS framework have been successfully applied to many domains, including single player games or problems [START_REF] Schadd | Single-player monte-carlo tree search[END_REF], General Game Playing [START_REF] Finnsson | Simulation-based approach to general game playing[END_REF], twoplayer games such as Hex [START_REF] Arneson | Monte carlo tree search in hex[END_REF], and naturally Go [Coulom, 2006], for which the now famous AlphaGo program [START_REF] Silver | Mastering the game of go with deep neural networks and tree search[END_REF] became the first program to beat a professional Go player.

Multi-objective case

The use of MCTS for MO optimization is quite recent. Let us assume in this section that the reward function to maximize is multi-dimensional: F : X -→ R p . Except in [START_REF] Wu | Multi-objective flexible job shop scheduling problem based on monte-carlo tree search[END_REF] and [START_REF] Wang | Hypervolume indicator and dominance reward based multi-objective monte-carlo tree search[END_REF], the few works published have made a focus on a specific domain of MO optimization: MO Online Reinforcement Learning (MOORL) [START_REF] Perez | Online and offline learning in multiobjective monte carlo tree search[END_REF]. The general idea of MOORL consists in controlling an agent in an unknown environment in which the agent has to discover step by step which actions should be performed in order to optimize a number of objectives. Naturally, computational resources allocated do not allow the agent to explore the whole environment. A MOORL problem can be modeled as the sequential decision problem defined in previous section with the following difference: the transition function t is generally stochastic: the state returned by the function partly depends on randomness, so that applying the same action from the same state twice may lead to a different state;

The great difference between MOORL problems with classical problems of Operations Research we consider (like MOTSP, MOKP, MOQAP, MOFSP, etc.) is that, in addition to the uncertainty induced by the transition function, the problem is not known in advance but locally discovered by the agent while performing actions. Given these features, the algorithms optimizing MOORL are highly general methods and a focus is made on their adaptability to any problem through online reinforcement learning techniques.

An example of MOORL problem is the MO Physical TSP (MOPTSP), a real-time game in which the player must drive a ship in a continuous 2D space in order to visit a series of way-points scattered around the world.

The path that is steered may contains obstacles to avoid, but unknown in advance. The three objectives to optimize are the time spent and the fuel consumed by the ship, but also the damages caused by obstacles to the ship.

MCTS algorithms developed for MO optimization can be separated into two distinct categories.

The first category of works concerns single-objective MCTS algorithms applied to MO problems. In [START_REF] Powley | Monte carlo tree search with macro-actions and heuristic route planning for the multiobjective physical travelling salesman problem[END_REF], the authors apply a single-objective MCTS method to MOPTSP for finding a single solution through optimization of a weighted-sum aggregation with a single fixed weight.

In [START_REF] Wu | Multi-objective flexible job shop scheduling problem based on monte-carlo tree search[END_REF], the authors propose a single-objective UCT method specifically designed for the MO Flexible Job-shop Scheduling Problem and combine it with single-objective LS. While the objectives are never optimized simultaneously, potentially efficient solutions are still memorized during the whole run. The method obtains similar results than competitors on very small instances containing less than five nondominated points.

The second category of works consists in real adaptations of MCTS to MOCO for finding the efficient set. To our knowledge, only two groups of authors have proposed such adaptations, differing from single-objective MCTS in two main aspects:

• an archive is now systematically maintained in order to memorize the best so far efficient set approximation found.

• as a random sampling now returns a vector reward instead of a scalar reward, the selection and backpropagation steps have to be adapted accordingly, as well as the statistics related to each node.

An initial attempt at adapting MCTS to MOCO was addressed in [Wang and[START_REF] Wang | [END_REF]Sebag, 2013]. Unfortunately, as suggested by the authors themselves, the two proposed methods were computationally prohibitive, and did not obtain convincing results (see [START_REF] Perez | Online and offline learning in multiobjective monte carlo tree search[END_REF]).

In the meantime, Perez et al. proposed an interesting adaptation of MCTS to MOCO into two studies [START_REF] Perez | Online and offline learning in multiobjective monte carlo tree search[END_REF], Perez et al., 2015], and we call it MOMCTS. They globally use the same scheme as UCT while including some differences. The main idea of the method is to evaluate a state by using the hypervolume indicator. First, each node of the partial tree built by the method contains an archive. Hence a random simulation generates a new solution x ∈ X, it is back-propagated in the tree and presented to the archive of each encountered node. If x is accepted in the archive of the current node, the back-propagation of x continues, otherwise it is stopped. This new back-propagation mechanism induces a slightly modified UCB formula for the selection step from a state s : arg max a∈A(s)

I H (Z(s), z) N (s, a) + c × ln N (s) N (s, a)
where Z(s) is the image in the objective space of the archive stored in the state s, and z is a predefined reference point (not indicated in the paper, probably the null vector).

This way, the root node memorizes the best-so-far approximation of the efficient set, and each node of the tree has an estimate of the quality of the solutions reachable from there. To our knowledge, MOMCTS has been tested on MOORL problems only: a small game called Deep Sea Treasure, on MOPTSP and a very similar bi-objective game, the Puddle Driver. MOMCTS found better results than the well-known MOEA called NSGAII [START_REF] Deb | A fast elitist non-dominated sorting genetic algorithm for multi-objective optimisation: Nsga-ii[END_REF] (which is, to our knowledge, far for being a state-of-the-art MOEA nowadays).

As suggested by the authors in [START_REF] Perez | Online and offline learning in multiobjective monte carlo tree search[END_REF], MOMCTS is not intended to compete with state-ofthe-art methods on classical Operations Research problems, but rather to propose an efficient method for MOORL research field only.

Nested Monte Carlo Search

An efficient Monte Carlo Search algorithm for single-player combinatorial problems is Nested Monte Carlo Search (NMCS) [Cazenave, 2009]. The principle of NMCS is different from the principle of MCTS. It still uses a lot of random simulations in order to find a good sequence of actions, but instead of building a partial game tree and collecting statistics from simulations, it memorizes the best sequence of actions found so far and follows it. It tries every possible actions from each traversed state and uses nested levels of search. Trying all possible actions enables NMCS to diversify the search, while memorizing the best sequence of actions enables it to intensify the search. The principle of NMCS is to use different levels of search. At level zero it performs a random simulation (lines 2-3). At greater levels (lines 4-16), it performs an iterative and more informed search. At each iteration, it generates all the available actions from the current state s, and for each action performed, it calls a level -1 search (lines 6-9). The nested search returns the best sequence of actions seq it found and the related solution x. As the simulations are stochastic, it is not guaranteed that a nested search will always improve on previous searches. In order not to lose the actions of the best sequence found by a previous search, NMCS memorizes the best sequence (lines 10-12). If none of the actions improve on the best sequence, the action of the best sequence is played; otherwise the best sequence is updated with the newly found sequence and the best action from the current state s is played (lines 13-14).

Figure 2.6 describes how a NMCS of level 1 uses random simulations to iteratively select the action to perform.

NMCS has been successfully applied on a number of different combinatorial problems. It has found world records on difficult problems [Kinny, 2012,Eliahou et al., 2013], has been applied to puzzles [Cazenave, 2009], software engineering [START_REF] Poulding | Generating structured test data with specific properties using nested monte-carlo search[END_REF] and transportation problems, such as the Bus Regulation Problem [START_REF] Cazenave | Monte-Carlo bus regulation[END_REF], and the Traveling Salesman with Time Windows Problem [START_REF] Rimmel | Optimization of the nested montecarlo algorithm on the traveling salesman problem with time windows[END_REF]. A combination with beam search has even been developed [Cazenave, 2012].

A related algorithm is Nested Rollout Policy Adaptation (NRPA) [Rosin, 2011] that learns a random simulation policy online using nested levels of learning. NRPA has found world records on difficult puzzles and has been applied to combinatorial problems such as the Traveling Salesman with Time Windows Problem [Cazenave andTeytaud, 2012, Edelkamp et al., 2013] and the Multiple Sequence Alignment Problem [START_REF] Edelkamp | Monte-carlo tree search for the multiple sequence alignment problem[END_REF]. Finally, Edelkamp and Greulich [START_REF] Edelkamp | Solving physical traveling salesman problems with policy adaptation[END_REF] used NRPA for MOPTSP and optimize a single objective.

To our knowledge, neither NMCS or NRPA have been adapted to MOCO.

MO Traveling Salesman Problem: state-of-the-art

This section first recalls some important techniques used for single-objective symmetric Traveling Salesman Problem (TSP), then reports a non-exhaustive literature review of optimization methods for MOTSP focused on meta-heuristics approaches.

Basic LS techniques for TSP

TSP is probably the most studied NP-hard single-objective combinatorial problem. We refer the reader to [START_REF] Gutin | The traveling salesman problem and its variations[END_REF] for an analysis of various methods for TSP and [START_REF] Rego | Traveling salesman problem heuristics: leading methods, implementations and latest advances[END_REF] for a survey of meta-heuristics and recent advances on TSP. We are interested here in ILS for TSP. Let N k be a k-neighborhood structure. For a number of optimization problems, all feasible solutions contain the same number of elementary components from E, and N k is called a k-exchange neighborhood structure. This is true for TSP, where a solution x ∈ X, which represents a Hamiltonian cycle (also called a tour) in a complete graph of n cities, is composed of n edges. In this context, let x ∈ X be another feasible solution, then x ∈ N k (x) if x is an Hamiltonian cycle obtained from x by exchanging k edges.

The most elementary neighborhood structure for TSP is the so-called 2-exchange neighborhood (Figure 2.7). A LS descent using a k-exchange neighborhood structure is called a k-opt.

A number of speed-up techniques for k-opt have been designed (see [Helsgaun, 2000, Helsgaun, 2009, Blazinskas and Misevicius, 2011] for details on the subject) and among them, two are essential: candidate edge list [START_REF] Johnson | The traveling salesman problem: A case study in local optimization[END_REF] and don't look bits [Bentley, 1992].

The candidate edge list technique consists in associating to each city a fixed-size list of candidate edges, generally the l best edges incident to the city minimizing the cost function of the addressed TSP instance. The list is limited to a reasonable size, compromise between quality and running time. ) and f i = (η 2i , η 2i+1 ) share a city, as well as f i and e i+1 , and f i belongs to the candidate list of city η i+1 . At the end, the last in-edge f k is chosen by default so as to be incident to the starting city, thus f k may not be a candidate edge and is called the close-up edge. This way, the edge sequence (e 1 , f 1 , e 2 , f 2 , ..., e k , f k ) constitutes a close chain of adjoining edges. Note that the choice of the in-edges is restricted at each step so as to obtain a (valid) new tour.

η 1 η 2 η 5 η 6 η 4 η 5 η 6 η 3 e 1 e 3 e 2 f 1 f 2 f 3 Figure 2.8 -
During an iteration of a k-opt, the don't look bits technique consists in ignoring as starting city a city η 1 which previously failed to find an improving move, and such that its city neighbors in the current tour have not changed since that time. In general, this technique greatly speeds-up a k-opt.

Figure 2.9 -An example of a double bridge move applied on a tour.

Concerning the perturbation move made during an ILS, the double bridge move [START_REF] Martin | Large-step markov chains for the traveling salesman problem[END_REF] (Figure 2.9) is one of the most popular. Given a tour to perturb, this move first gives a direction to the tour, then cuts the current tour at four appropriately chosen edges into four sub-tours and reconnects these in a different order to yield a new starting tour without changing the direction.

Probably the most utilized and efficient method for TSP is an ILS called Lin-Kernighan [START_REF] Lin | An effective heuristic algorithm for the traveling-salesman problem[END_REF]. This method uses the VND concept and the double-bridge move as perturbation move. Nowadays, two improved versions are generally used in the literature: Chained Lin-Kernighan (C-LK) [START_REF] Applegate | Chained lin-kernighan for large traveling salesman problems[END_REF] designed by Applegate, Cook and Rohe, and the Lin-Kernighan implementation of Helsgaun (LKH) [Helsgaun, 2000].

Instead of perturbing the current solution to escape from the attraction basin of a local optimum, the technique of data perturbation (also called noising method) [START_REF] Charon | The noising method: a new method for combinatorial optimization[END_REF], Codenotti et al., 1996, Charon and Hudry, 2002] suggests to modify input data by adding a random noise to the cost function of the addressed instance. This way, one hopes that the next LS descent will direct its search towards a different local optimum.

Literature review for MOTSP

This section presents a number of meta-heuristics and a single exact approach for MOTSP. Some methods are more detailed than others due to their significance for the optimization methods proposed later in the document. In particular, we start with out-of-date yet interesting methods and finish with the current best methods on MOTSP.

• To our knowledge, Jaszkiewicz is the first author having published approximations of non-dominated sets of bi-objective TSP instances. In [Jaszkiewicz, 2002], he proposed an improved version of the MO Genetic local search (MOGLS) initially proposed by Ishibushi and Murata [Ishibuchi and[START_REF] Ishibuchi | [END_REF][START_REF] Ishibuchi | [END_REF]], who applied it on MOFSP.

In particular, the authors use the concept of locked edges [Jaszkiewicz, 1999], consisting in forbidding the use of frequent edges in order to speed-up the optimization process.

• Jaszkiewicz and Zielniewicz have experimented on bi-objective instances the Pareto Memetic Algorithm (PMA) [START_REF] Jaszkiewicz | Efficient adaptation of the pareto memetic algorithm to the multiple objective travelling salesperson problem[END_REF] and found better results than MOGLS.

• Kumar and Singh [START_REF] Kumar | Pareto evolutionary algorithm hybridized with local search for biobjective TSP[END_REF] introduce a memetic algorithm and find comparable results to MOGLS and PD-TPLS (presented below in paragraph Two-Phase Local Search) on bi-objective instances.

• The Evolutionary MO Simulated Annealing Algorithm (EMOSA) [START_REF] Li | An adaptive evolutionary multi-objective approach based on simulated annealing[END_REF] of Li and Landa-Silva (rapidly described in Section 2.2.3.2) is compared with other MOSA-like algorithms and obtains better results on all tested bi-objective and tri-objective TSP instances (of sizes from 50 to 100). However, the SA used to optimize each considered weighted sum problem uses a simple 2-exchange neighborhood, without any LS speed-up techniques, making EMOSA irremediably non-competitive compared to the best current methods on MOTSP.

• Various MO Ant Colony Optimization (MOACO) algorithms have been proposed in recent years (see [START_REF] Cheng | Multi-objective ant colony optimization based on decomposition for bi-objective traveling salesman problems[END_REF], García-Martínez et al., 2007] among others). López-Ibáñez and Stützle [López-Ibáñez and Stützle, 2012] propose a framework that suffices to describe most MOACO algorithms proposed so far. The authors tested different optimized configurations of this framework on Euclidean bi-objective TSP, and found better MOACO algorithms than those available in the literature. However, like EMOSA, results of MOACO are not comparable to the best current methods on MOTSP.

• MOEA/D-ACO [START_REF] Ke | Moea/d-aco: A multiobjective evolutionary algorithm using decomposition and antcolony[END_REF] combines MOEA/D with a MOACO algorithm. Like EMOSA and MOACO, results of MOEA/D-ACO are not comparable to the best current methods on MOTSP.

Let us now present particularly interesting works concerning MOTSP.

AUGMECON2

Recently, Florios and Mavrotas [START_REF] Florios | Generation of the exact pareto set in multi-objective traveling salesman and set covering problems[END_REF] proposed an ε-constraint method called AUG-MECON2 for solving exactly MOTSP. To our knowledge, they provided the exact non-dominated sets of 16 bi-objective instances of size 100, a single bi-objective instance of size 150 and a single tri-objective instance of size 15. Although AUGMECON2 provides the guarantee of finding the non-dominated set in theory, the method has huge limitations in practice.

First, while current best meta-heuristics obtain quite good results on bi-objective instances of size 100 within running times around several seconds, at most a minute, AUGMECON2 finds in average in 30 hours the non-dominated set of such instances (on similar computers). In addition, the method scales badly with the instance size: it takes several days for finding the non-dominated set of a bi-objective instance of size 150.

According to the authors, this instance pushed to its limits AUGMECON2. Finally, the method does not scale at all with the number of objectives as the largest tri-objective instance handle by AUGMECON2 was a 15 cities instance solved in 5 hours.

The authors concluded that the generation of the exact non-dominated set for tri-objective TSP, even of small size (20-30 cities), is rather an utopian task and the use of approximate algorithms seems to be the only choice.

AUGMECON2 corresponds to a great step of exact methods for bi-objective TSP. By contrast, it highlights the difficulty of exact methods to scale well with both the instance size and the number of objectives, and strengthens the idea of the usefulness of meta-heuristics for such a hard problem.

Two-Phase Local Search

Paquete and Stützle introduce in [START_REF] Paquete | A two-phase local search for the biobjective traveling salesman problem[END_REF] the concept of Two-Phase Local Search (TPLS), later generalized in [START_REF] Paquete | Design and analysis of stochastic local search for the multiobjective traveling salesman problem[END_REF].

TPLS first generates a sequence of weights with MDW, sorted such that the first weight considers a single objective, and successive weights differ only by ± 1 D in any two objectives, where D is the parameter of MDW controlling the number of weights generated. Then TPLS iterates on the sequence of weights and optimizes the weighted sum problem corresponding to each weight with an ILS, starting from the best solution found at the preceding iteration. The first starting solution is greedily generated at random. Double TPLS (D-TPLS) runs TPLS p times such that the first weight considers a different objective each time.

Pareto Double TPLS (PD-TPLS) consists in two phases. The first phase runs D-TPLS, and the second phase conducts a single iteration of PLS from the solutions generated by D-TPLS.

The ILS optimizing the weighted sum problems uses a 3-opt with the speed-up techniques previously introduced. During the second phase of PD-TPLS, the single iteration of PLS uses the same candidate lists and neighborhood structures as ILS.

PD-TPLS has been tested on bi-objective TSP instances of sizes from 100 to 500 and finds better results than MOGLS [START_REF] Paquete | A two-phase local search for the biobjective traveling salesman problem[END_REF]. Contrary to PD-TPLS, D-TPLS has been tested on tri-objective instances of sizes from 100 to 300 and finds better results than MOGLS [START_REF] Paquete | Design and analysis of stochastic local search for the multiobjective traveling salesman problem[END_REF]. As indicated by the authors, PD-TPLS has not been used for p = 3 as the single PLS iteration conducted in the second phase generated to much solutions.

In [START_REF] Dubois-Lacoste | Improving the anytime behavior of two-phase local search[END_REF], Dubois-Lacoste et al. analyze and improve the anytime behavior of TPLS.

2PPLS

While 2PPLS [START_REF] Lust | Two-phase pareto local search for the biobjective traveling salesman problem[END_REF] is no longer the best heuristic for MOTSP, it is probably the most important as their authors proposed several interesting and highly efficient speed-up techniques for MOTSP. As previously indicated in Section 2.2.3.6, 2PPLS introduces the concept of 2-Phase PLS. Originally designed for the bi-objective case only, 2PPLS introduces an approximation version of the dichotomic scheme [Cohon, 1978, Aneja andNair, 1979] to approximate the supported efficient set in the first phase. The solver used to optimize the different weighted sum problems is chained Lin-Kernighan (C-LK) [START_REF] Applegate | Chained lin-kernighan for large traveling salesman problems[END_REF].

For the second phase, PLS uses a 2-exchange neighborhood structure, and originally PLS did not use candidate edge lists, making the convergence of PLS extremely slow. The authors thus propose to speed-up PLS by adapting the concept of candidate edge list for the MO case. In fact, memorizing into the candidate edge list of each city the l best edges is no longer possible in MOCO, as this technique assumes a total order of the edges given a cost function c, while such an order is absent in MOCO. On the other hand, they found that the set of all edges present in at least one solution of the global archive at the end of the first phase, and the set of all edges used in at least one solution of the global archive at the end of the second phase are very similar.

In consequence, they decided to insert into the candidate edge lists of PLS the set of all edges present in at least one solution of the global archive at the end of the first phase. 2PPLS with this speed-up technique is called 2PPLS-SpeedP1 [START_REF] Lust | Speed-up techniques for solving large-scale biobjective TSP[END_REF]. Experiments showed that 2PPLS-SpeedP1 obtains in average an approximation of slightly worse quality compared to 2PPLS but with a much faster convergence, particularly when the instance size grows.

In addition to the candidate edge list for PLS, the authors proposed an adaptation of don't look bits for PLS. However, contrary to the single-objective case, even though this technique reduces the running time of PLS, it also drastically reduces the results quality and this proposition of don't look bits for MOTSP does not seem to be viable for now.

In order to reduce the convergence time of PLS and produce a better quality approximation, the authors propose to generate an even better quality starting set during phase one. The authors stated that while the dichotomic scheme has already found many supported efficient solutions, the improvement of the starting set can only be done by generating non-supported efficient solutions. To do so, after the dichotomic scheme and before PLS, they generate a number of weights with MDW, then optimize each related weighted sum problem with C-LK after having perturbed it with data perturbation. They tested this technique on smallsize instances (n = 100, 200) and found good results, but surprisingly, the authors do not go further with data perturbation in their next study on MOTSP [START_REF] Lust | Speed-up techniques for solving large-scale biobjective TSP[END_REF], maybe due to the high number of parameters needed (3) while data perturbation is just a component among others of a more general method.

To conclude on 2PPLS, experiments conducted in [START_REF] Lust | Two-phase pareto local search for the biobjective traveling salesman problem[END_REF] and [START_REF] Lust | Speed-up techniques for solving large-scale biobjective TSP[END_REF] show that 2PPLS and its variants outperform MOGLS and PMA on tested bi-objective instances of sizes from 100 to 1000.

MoMad

MoMad [START_REF] Ke | A simple yet efficient multiobjective combinatorial optimization method using decompostion and pareto local search[END_REF] has already been described in Section 2.2.4. Like 2PPLS-SpeedP1, MoMad uses Chained Lin-Kernighan as solver for initialization; and both PLS and the LS descent of the main loop use a 2-opt with candidate lists containing all edges of the solutions accepted in the global archive. MoMad has been tested on bi-objective instances of sizes from 200 to 1000 and experiments showed that MoMad outperforms 2PPLS-SpeedP1 on tested instances.

Perturbed Decomposition Algorithm

Perturbed Decomposition Algorithm (PDA) [START_REF] Cornu | Perturbed decomposition algorithm applied to the multi-objective traveling salesman problem[END_REF] is an enhanced version of MoMad we have recently proposed to tackle MOTSP. At main loop, PDA optimizes the sub-problems with a 3-opt ILS run (instead of a 2-opt LS descent), and memorizes all incomparable local optima produced by C-LK (at initialization) and ILS (at main loop). PDA introduces data perturbation into the decomposition framework: the sub-problems are data perturbed at initialization and the sub-problem providing the lowest number of solutions accepted in the global archive is re-data perturbed in order to diversify the search. PDA has been compared to MoMad and PD-TPLS on a benchmark of bi-objective instances of sizes from 100 to 1000, and tri-objective instances of sizes from 30 to 300. PDA obtained better results than its competitors. Therefore, PDA is the current best heuristic for bi-objective and tri-objective TSP.

In consequence, MoMad is the best heuristic for bi-objective TSP proposed by other authors, and (PD-)TPLS is the best heuristic for tri-objective TSP proposed by other authors.

Recent works published during the drafting process

The research field of MOTSP optimization is pretty dynamic, and very recently two interesting works have been published. We do not have taken them into account as they have been published during the drafting process of this thesis. Lust and Jaszkiewicz [START_REF] Jaszkiewicz | Proper balance between search towards and along pareto front: biobjective tsp case study[END_REF] propose and improved version of 2PPLS by better controlling the number of runs of ILS in order to re-launch PLS and obtain better results. The method obtains results at least comparable to MoMad.

In [Jaszkiewicz, 2017], Jaszkiewicz proposes a version of PLS able to tackle efficiently the many-objective case.

Archives: state-of-the-art

In MO optimization problems, archives are used to store incomparable solutions. There exists two main scenarios:

• the offline scenario: a whole set of solutions known in advance is presented to an initially empty archive.

• the online scenario: an unknown number of solutions are presented one by one to an archive.

Specific algorithms have been developed for each scenario. The offline scenario is intensively studied (see [START_REF] Kung | On finding the maxima of a set of vectors[END_REF] for a discussion and some theoretical results on the subject) and many different algorithms have been developed, particularly these few years [START_REF] Zhang | Empirical analysis of a tree-based efficient non-dominated sorting approach for many-objective optimization[END_REF]. This scenario occurs in two main situations: when proceeding to the non-dominated sorting [Goldberg, 1989] of a solution set and when computing the hypervolume of a solution set. In both situations, an efficient algorithm for archiving is crucial for good performance.

Given a set of points in the objective space, Non-Dominated Sorting [Goldberg, 1989] aims at assigning a rank to each point such that the lower rank, of better quality the point. It consists in partitioning a given set of solutions into several archives. This process is iterative and manages a current set of solutions, initialized with the initial solution set. At each iteration i, all points not dominated are extracted from the current set and constitute the front of solutions of rank i. The process stops when the current solution set is empty. Non-dominated sorting is often used in a number of MOEA, in order to select solutions during the parent selection and population update steps (cf Section 2.2.2). We refer the reader to [START_REF] Zhang | Empirical analysis of a tree-based efficient non-dominated sorting approach for many-objective optimization[END_REF] for a survey on algorithms for non-dominated sorting.

Concerning the use of archives for hypervolume computation of a set of solutions, dedicated algorithms partition the archive into sub-archives in smaller dimensions. We refer the reader to [START_REF] Fonseca | An improved dimensionsweep algorithm for the hypervolume indicator[END_REF] and [START_REF] While | A fast way of calculating exact hypervolumes[END_REF] for more details.

We are only concerned by the online scenario. In practice, this scenario occurs when an archive is employed within a MO optimization method, which regularly presents a newly generated solution to the archive throughout the run. In fact, the computational cost required to maintain an archive may become an important part of the total computational cost of a number of MOCO methods, such as search regionsbased [START_REF] Klamroth | On the representation of the search region in multi-objective optimization[END_REF], MO dynamic programming [Bazgan et al., 2009a] or PLS. The rest of this section is dedicated to a non-exhaustive literature review of the most popular or efficient archives for the online scenario. In particular, we make a focus on algorithms which inspired us for the design of a number of components of the archives we propose. We refer the reader to [START_REF] Altwaijry | Data structures in multi-objective evolutionary algorithms[END_REF] for a quite recent survey on archives.

Linear list

The simplest data structure for managing an archive is the linear list. In this structure, a candidate solution is compared to all solutions except if a solution weakly dominates the candidate; in this case the candidate is rejected. Otherwise, all the dominated solutions of the list are removed and the candidate is inserted. Whether the candidate is accepted or rejected, the complexity in terms of number of dominance comparisons is in O(p×s), where s is the size of the archive. Although not competitive at all compared to the best current archives [START_REF] Jaszkiewicz | Nd-tree: a fast online algorithm for updating a pareto archive and its application in many-objective pareto local search[END_REF], the linear list is probably the most used algorithm for managing a set of incomparable solutions. As examples among many others, [Bazgan et al., 2009a] and [START_REF] Li | Efficient non-domination level update approach for steady-state evolutionary multiobjective optimization[END_REF]] use a linear list as archive, while they are considered as state-of-the-art methods on their respective domains.

In [START_REF] Bentley | Fast linear expected-time algorithms for computing maxima and convex hulls[END_REF], the authors propose a simple yet efficient speed-up technique when using a linear list called Move-to-Front:

• if the candidate solution is accepted, then insert it in front of the list;

• otherwise, push in front of the list the solution dominating the candidate.

This technique does not improve the worst case complexity but experiments show that it greatly reduces the overall running time.

Sorted list

A sorted list uses the fact that in the bi-objective case, if incomparable solutions are sorted in increasing order of their coordinates on one objective, they are also sorted in decreasing order of their coordinates on the other objective. A sorted list works as follows. The solutions are maintained sorted in increasing order on the first (or the second) objective. When a candidate solution is presented to the list, a binary search using the sorting objective is performed to determine where to place the candidate. During the binary search, if a solution selected for the dichotomy decision weakly dominates the candidate, then the candidate is immediately rejected.

Once the candidate is placed, all the solutions at its left have a better value on the sorting objective while all the solutions at its right have a worse value. Therefore, if the preceding solution weakly dominates the candidate, then the candidate is rejected. Otherwise, the candidate is accepted; and any succeeding solution with a worse value than the candidate on the non-sorting objective is removed.

To have a constant time access to the solutions of the list during the binary search, the sorted list is implemented as a dynamic array. Therefore, once a solution is removed from the list, all the succeeding solutions are shifted to the left. Note that if only one solution is dominated, then the candidate simply replaces it and the succeeding solutions are not shifted; in this case, the complexity in time is in O(p×log 2 s), where s is the size of the archive. Otherwise, if the candidate is accepted and dominates more than one solution, the complexity in time is in O(p × s). But on average, as recalled in [START_REF] Jaszkiewicz | Nd-tree: a fast online algorithm for updating a pareto archive and its application in many-objective pareto local search[END_REF], experiments show that the behavior of the sorted list is much better than the simple list since the worst-case scenario rarely occurs.

Quad-tree

Originally, a Quad-tree [START_REF] Finkel | Quad trees a data structure for retrieval on composite keys[END_REF]] is a tree-based data structure for indexing points in a multi-dimensional space. In [Habenicht, 1983], Quad-tree has been adapted as archive, then further developed in [START_REF] Sun | Quad-trees and linear lists for identifying nondominated criterion vectors[END_REF] and [START_REF] Mostaghim | Quad-trees: A data structure for storing pareto sets in multiobjective evolutionary algorithms with elitism[END_REF]. This data structure is based on the following observation: given a point z ∈ Z, the p-dimensional multi-objective space can be partitioned into 2 p regions with z as reference point, called orthants of z, such that all points in the same orthant have the same relative positioning with respect to z. In a Quad-tree, solutions are located in both internal and leaf nodes and each node η has at most 2 p -2 children. Each child of η is the root of a subtree memorizing all points localized in an orthant of the image z = f (x) of the solution x ∈ X stored in η. As a Quad-tree is an archive, the orthants dominating z and dominated by z can not exist. A Quad-tree can thus be seen as a hierarchy of orthants and this organization of data allows to guide efficiently the exploration of the tree. Figure 2.10 illustrates a Quad-tree in the bi-objective case.

Different versions of Quad-tree have been developed. We are particularly interested by the implementation proposed in [Tricoire, 2012], working as follows. When a candidate solution is presented to the Quad-tree, a first procedure explores the tree in order to check if the candidate is weakly dominated by a solution. If the candidate is accepted, then a second procedure identifies the nodes dominated by the candidate and extract any subtree whose root is dominated. Finally, a third procedure inserts the candidate and reinsert non-dominated parts of previously extracted sub-trees.

• a

• c • e • b • d a b c d e Figure 2
.10 -A Quad-tree in the bi-objective case.

• • • • • • • • R A B a 1 a 2 R A B a 1 a 2 Figure 2.11 -A ND-Tree in the bi-objective case.
Quad-tree is efficient for checking if a candidate solution is weakly dominated or not, and inserting a new solution is computationally cheap. By contrast, once a solution of the Quad-tree is dominated, re-insertions are generally needed, while they are costly operations.

ND-Tree

Recently, Jaszkiewicz and Lust [START_REF] Jaszkiewicz | Nd-tree: a fast online algorithm for updating a pareto archive and its application in many-objective pareto local search[END_REF] proposed a new tree-based archive called ND-Tree. A ND-Tree stores the solutions in leaf nodes only. Each leaf node stores in a linear list a number of solutions neighbors in the objective space. Each (internal or leaf) node maintains approximate local ideal and nadir points, which define a bounding box including all the images (in the objective space) of the solutions stored in the subtree. The originality of the ND-tree comes from the use of basic properties of local ideal and nadir points to efficiently avoid searching many branches in the tree. A ND-Tree works as follows. When a candidate solution is presented to the ND-Tree, a first procedure explores the tree to check if the candidate is weakly dominated by any solution. If yes, the candidate is rejected. Otherwise, the candidate is accepted and dominated sub-trees and solutions are removed. Then a second procedure inserts it in a suitable leaf.

More precisely, the first procedure explores the tree using Depth First Search (DFS) starting from the root. For each traversed node, only four cases are possible (see [START_REF] Jaszkiewicz | Nd-tree: a fast online algorithm for updating a pareto archive and its application in many-objective pareto local search[END_REF] for proofs):

• If the approximate local nadir point weakly dominates the candidate, then all solutions contained in the node weakly dominate the candidate, therefore it is rejected.

• Otherwise, if the candidate dominates the approximate local ideal of the node, then all solutions contained in the node are dominated by the candidate. Therefore the subtree rooted at the node is removed and the candidate is accepted.

• Otherwise, if the approximate local ideal weakly dominates the candidate, or the candidate weakly dominates the local nadir, this means that the candidate is potentially weakly dominated or dominates a solution contained in the subtree. In this case:

-If the node is a leaf, then the candidate is compared to each solution of the node. If a solution weakly dominates the candidate, then the candidate is rejected. Otherwise, any solution dominated by the candidate is removed.

-Otherwise, the procedure is called from each child node. If the candidate is rejected by a child node, then it is rejected, otherwise it is accepted.

• Otherwise (the node is internal), the candidate is incomparable with both the approximate local ideal and nadir points. Therefore, the candidate is incomparable with all solutions stored in this subtree, and the current node is not explored.

Any empty node is removed from the tree during this first procedure.

Once the candidate is accepted, the second procedure aims at inserting the candidate in a suitable leaf of the tree. To do so, the tree is browsed by following a unique top-down path starting from the root and ending to a leaf. For each internal node traversed, the descent continues in the child node η for which the candidate is the closest from the center of its bounding box. When a leaf is reached, the solution is inserted, and the approximate local ideal and nadir of the leaf and of its ascendants are updated such that the corresponding bounding boxes contain the new solution.

Only a limited number of solutions is allowed in a single leaf node. If a leaf becomes overfilled after the insertion of a new solution, then it is split into l (l ≥ 2) new leaves. The solutions contained in the split node are then redistributed to every new leaves, such that each leave contains at least one solution and, solutions neighbors in the objective space tend to be inserted in the same node. Then, the split node becomes an internal node with the l new leaves as children.

Note that the local and nadir points maintained by each node are approximated because they are updated only when a solution is inserted, but not when a solution is removed, which is less computationally costly.

In [START_REF] Jaszkiewicz | Nd-tree: a fast online algorithm for updating a pareto archive and its application in many-objective pareto local search[END_REF], the authors do not evaluate the worst case complexity of ND-tree. However they experimentally show that ND-Tree outperforms previous state-of-the-art structures, i.e. linear list, Quad-tree and the algorithm presented in [START_REF] Drozdik | Computational cost reduction of nondominated sorting using the m-front[END_REF] on different artificial benchmarks up to 6 objectives, and is equivalent to sorted list on bi-objective instances.

To our knowledge, ND-Tree is the current best archive for the online scenario.

Chapter 3

New archives

This chapter introduces two new archives offering efficient and original features: AVL-Archive specialized for bi-objective space, and NDR*-Archive for any-objective spaces. Both structures are self-balancing trees and benefit from self-adjusting versions, especially designed if a presumption of temporal and spatial locality exists between the solutions presented to the archive. In experiments, the archives we propose are compared with the best known archives of the literature on a large benchmark of instances simulating the generation of points of a MO meta-heuristic, and inside a PLS for MOTSP up to 5 objectives.

Introduction

The current best known archives, the sorted list for the bi-objective case and ND-Tree have shown good results on last studies on the online scenario (previously introduced in Section 2.4). However, we claim that both archives suffer from two crucial drawbacks: they are unbalanced tree structures, which can lead to nasty worst case scenario; and they do not take advantage of a principle often present when storing data in an online environment: the temporal and spatial locality. Temporal locality refers to the reuse of specific data within a relatively small time duration, while spatial locality refers to the use of data elements within relatively close storage locations1 .

The two data structures proposed in the present section have been designed to overcome the drawbacks of the sorted list and ND-Tree. With this aim, two objectives have been considered:

1. Minimization of the number of dominance comparisons necessary to check the acceptance/rejection of a candidate solution. For this purpose, self-balancing trees are used.

2. Minimization of the computational cost necessary to maintain the properties of the structures, in particular the balance property previously stated.

In general, an archive with strong properties constraining its structure will induce an onerous structure maintenance but a low number of dominance comparisons. On the contrary, a weakly constrained structure will tend to a high number of dominance comparisons. Therefore, both objectives are conflicting.

The general idea is to favor the first objective, while constraining the budget of the structure maintenance.

The first proposed data structure is a self-balancing binary search tree confined to the bi-objective case, called AVL-Archive. The second proposed data structure is a self-balancing k-ary search tree, called NDR*-Archive.

For both data structures, two different versions are presented: the vanilla version and the self-adjusting version. The vanilla versions of both AVL-Archive and NDR*-Archive are general and suitable for any MO optimization task. The self-adjusting versions are especially designed if a presumption of temporal and spatial locality exists between the points generated by the MO optimization method. This is the case of PLS, a method we are particularly interested in, because of two main reasons:

• A solution and its neighbors found by PLS are generally close to each other in the objective space.

• The neighborhood of a solution is completely explored before considering the exploration of the neighborhood of another solution.

This chapter is organized as follows. Sections 3.1 and 3.2 detail the design of the proposed data structures and their self-adjusting versions. Section 3.3 is devoted to experiments: the vanilla version of the proposed archives are tested on a large artificial benchmark and their self-adjusting versions are applied within PLS on MOTSP.

AVL-Archive

An AVL-tree [Adelson-Velskii, 1962] is a self-height-balancing binary search tree used for storing and managing a number of elements indexed with a scalar key on a single comparison dimension. This tree is characterized by the three following properties:

As an indexing structure, the tree handles the following operations: searching, inserting and removing a single element.

As a binary search tree:

• any node of the tree has at most two children and each node contains a unique indexed element;

• given a node η of the tree and x the element stored in η: any element stored in the left subtree of η has a smaller key value than x; any element stored in the right subtree of η has a larger key value than x.

As a self-balancing structure:

• any node η maintains an attribute called balance factor, which is the difference between the height of the right and the left subtrees of η;

• the tree is maintained balanced, meaning that the balance factor of any node is maintained in {-1, 0, 1}. This property directly implies that the height of an AVL-tree is maintained to O(log 2 s), where s is the number of nodes in the tree.

To remain balanced, an AVL-tree re-balances any subtree unbalanced after inserting or removing a single node. Since the balance factor of any node is maintained in {-1, 0, 1}, when a subtree is unbalanced, the balance factor of its root is -2 or 2, and it is re-balanced through an operation called rotation.

A rotation is a reorganization of the nodes of a subtree such that parts of the left/rightside of the subtree are transferred to the other side. At the end of a rotation, the root of the subtree has changed and the subtree is balanced.

In [Adelson-Velskii, 1962], the authors distinguish only four possible cases of imbalance of a subtree and propose a unique rotation for each case. Once a node η is inserted or removed, we check if its parent node is balanced and apply a rotation if it does not. When performed, a rotation may propagate the imbalance upward in the tree, thus several rotations might be necessary until the complete tree is balanced. This section introduces AVL-Archive, the new archive we propose for the bi-objective case and based on AVL-tree. In the remaining of this section, we assume the objective space is bi-dimensional, i.e. p = 2.

Design of AVL-Archive

Like AVL-tree, AVL-Archive is a self-height-balancing binary search tree using four different rotations to stay balanced. By contrast, an AVL-Archive is especially designed for archiving. Second, it uses interesting properties exclusive to the bi-objective case to store incomparable solutions and efficiently remove dominated solutions. Third, it may happen that complete subtrees are removed; the archive must then be able to rebalance subtrees related to an imbalance factor with an absolute value larger than 2, which is not the case of AVL-tree. Let us now describe more precisely how an AVL-Archive works.

Each node η of an AVL-Archive (cf. Figure 3.1) is associated with:

• a solution x(η) ∈ X. In the following, for the sake of simplicity, we say that a solution x (resp. weakly) dominates a node

η if f (x) (resp. weakly) dominates f (x(η)); η p(η) l(η) r(η) h(η) β(η) Θ(η)
Figure 3.1 -Illustration of a node η with its attributes in an AVL-Archive.

• its parent node p(η)

• its two children: the left child l(η) and the right child r(η);

• the subtree Θ(η) rooted at η;

• its height h(η) (also noted h(Θ(η))), equal to the size of the path from η to the most distant leaf of Θ(η);

• its balance factor β(η), corresponding to the difference between the height of its right subtree and the height of its left subtree:

β(η) = h(r(η)) -h(l(η))
Let |β(η)| be called the absolute balance factor.

Given these notations, the left (resp. right) subtree of a node η is denoted Θ(l(η)) (resp. Θ(r(η))).

Definition 3.1.1. A node η is said to be balanced if |β(η)| ≤ 1.
A tree is said to be balanced iff. each of its node is balanced.

The structural organization of AVL-Archive is defined by the two following fundamental properties.

Property 3.1.1. Any subtree of an AVL-Archive is a binary search tree using the first objective as comparison dimension. More formally, for any node η, for any node η l ∈ Θ(l(η)), we have f 1 (x(η l )) < f 1 (x(η)); and for any node η r ∈ Θ(r(η)), we have

f 1 (x(η)) < f 1 (x(η r )).
The next proposition is complementary to Property 3.1.1.

Proposition 3.1.1. Let η be a node. For any node η l ∈ Θ(l(η)), we have f 2 (x(η l )) > f 2 (x(η)); and for any node η r ∈ Θ(r(η)), we have

f 2 (x(η)) > f 2 (x(η r )). Proof. By Property 3.1.1, we have f 1 (x(η l )) < f 1 (x(η)
). Since x is incomparable with any solution of the archive and p = 2, we have

f 2 (x(η l )) > f 2 (x(η)
). The proof is similar for Θ(r(η)).

Property 3.1.1 and Proposition 3.1.1 combined indicate that for any node η of the tree:

• solutions in the left subtree of η have a smaller value than x(η) in the first objective and a larger value than x(η) in the second objective.

• solutions in the right subtree of η have a larger value than x(η) in the first objective and a smaller value than x(η) in the second objective.

Property 3.1.2. Any subtree of an AVL-Archive is maintained balanced in height. More formally, for any node η, |β(η)| ≤ 1.

Proposition 3.1.2. The height of an AVL-Archive is maintained to O(log 2 s), where s is the number of nodes in the tree.

Proof. Obvious from Property 3.1.2.

An AVL-Archive works as follows. When a candidate solution x ∈ X is presented to the archive, a dichotomic search is performed from the root of the tree. If the candidate is weakly dominated by a node, then it is rejected. Otherwise, if the candidate dominates a node, then the candidate replaces the solution of the node, dominated subtrees are removed through a procedure called pruning, and the candidate is accepted.

Otherwise the candidate is incomparable with any solution of the archive, thus it is inserted in a new leaf node and is accepted.

In both cases where the candidate is accepted, node insertions and node removals may unbalance affected subtrees. The imbalance of a subtree is detected when its root has an absolute balance factor greater than or equal to 2. Such subtrees are re-balanced using rotations from their root. Because a rotation performed from a node may propagate the imbalance upward in the tree, several rotations might be necessary until the complete tree is balanced (as in AVL-tree).

General algorithm of AVL-Archive

Let us now describe more precisely the AVL-Archive algorithm. The Add procedure is the core of an AVL-Archive. It is described with a diagram in Figure 3.2 and detailed in pseudo-code by Algorithm 12. This procedure takes as parameter a calling node η and a candidate solution x ∈ X. It is initially called from the root of the tree. It returns true iff. x is not weakly dominated by any solution in the archive.

First, x is compared to the solution of the current node η:

• If x is weakly dominated by x(η) (lines 1-2), then the candidate x is rejected.

• Otherwise, if x dominates x(η) (lines 3-18), then x replaces it. A number of nodes in the current subtree may be dominated and thus have to be removed. We call this process pruning. First, both left and right subtrees of η are disconnected from η (lines 6 and 12). Second, they are independently pruned via the LeftPruning and RightPruning procedures (lines 7 and 13). Third, if the subtrees become unbalanced, they are (independently) re-balanced with rotations via the ReBalanceAfterDelete procedure (lines 9 and 15). As both subtrees have been previously disconnected from η, the re-balancing procedure does not operate upward their respective root. Fourth, both subtrees are reconnected to η (lines 10 and 16), then the whole tree is re-balanced by calling ReBalanceAfterDelete procedure from η (lines 17-18). Finally the candidate is accepted.

Apply a dichotomic search from the root until reaching the first node η s.t. :

• either x is weakly dominated by x(η)

• or x dominates x(η) • or η is a leaf.
if f (x(η)) f (x) then return false else if f (x) ≤ f (x(η)) then x(η) ← x if η has a left child then p(l(η)) = none uη ← LeftPruning(l(η), l(η), x) if a node has been deleted from Θ(l(η)) then lη ← ReBalanceAfterDelete(uη) l(η) ← lη; p(lη) ← η if η has a right child then p(r(η)) = none uη ← RightPruning(r(η), r(η), x) if a node has been deleted from Θ(r(η)) then rη ← ReBalanceAfterDelete(uη) r(η) ← rη; p(rη) ← η if a node has been deleted from Θ(l(η)) or Θ(r(η)) then root ←ReBalanceAfterDelete(η) else if f 1 (x) < f 1 (x(η)) then if η has a left child then return Add(l(η), x) else l(η) ← new node(x, η) ReBalanceAfterInsert(η) else if η has a right child then return Add(r(η), x) else r(η) ← new node(x, η) ReBalanceAfterInsert(η)
return true

• Otherwise (lines 19-30), x and x(η) are incomparable:

-If f 1 (x) < f 1 (x(η))
, the Add procedure is recalled from the left child of η.

-Otherwise, the Add procedure is recalled from the right child of η .

In both cases, if there is no child, x is inserted in a new node and the whole tree is re-balanced by calling the ReBalanceAfterInsert procedure from its parent, which performs a number of rotations, then the candidate is accepted.

Pruning process

Let us assume that during the dichotomic search of the Add procedure, a node η is found such that the candidate solution x dominates η. Therefore, x(η) is replaced by x, then Θ(l(η)) and Θ(r(η)) are disconnected from η. This triggers the pruning process which aims at removing dominated nodes in Θ(l(η)) and Θ(r(η)) by starting independently from l(η) and r(η).

Proposition 3.1.3. Let x ∈ X be a candidate solution, η a node, x = x(η), η l ∈ Θ(l(η)), x l = x(η l ), η r ∈ Θ(r(η)) and x r = x(η r ) such that f (x) ≤ f (x).
(

) (i) If f 1 (x) ≤ f 1 (x l ), then f (x) ≤ f (x l ) and f (x) ≤ f (x ) for any solution x in Θ(r(η l )) (ii) Otherwise, f (x) f (x l ) and f (x) f (x ) for any solution x in Θ(l(η l )). 1
(

) (i) If f 2 (x) ≤ f 2 (x r ), then f (x) ≤ f (x r ) and f (x) ≤ f (x ) for any solution x in Θ(l(η r )). 2
(ii) Otherwise, f (x) f (x r ) and f (x) f (x ) for any solution x in Θ(r(η r )).

Proof.

(1) (i) From Proposition 3.1.1, we have

f 2 (x) < f 2 (x l ) which involves f 2 (x) < f 2 (x l ) and thus f (x) ≤ f (x l ) since f 1 (x) ≤ f 1 (x l ). Moreover, since x is in the right subtree of η l we have f 1 (x l ) ≤ f 1 (x ), which gives f 1 (x) ≤ f 1 (x ) since f 1 (x) ≤ f 1 (x l ).
Finally, since x is in the left subtree of η, we have

f 2 (x) < f 2 (x ), which gives f 2 (x) ≤ f 2 (x ) since f (x) ≤ f (x). It follows that f (x) ≤ f (x ).
(1) (ii) we have

f 1 (x l ) < f 1 (x) which involves f 1 (x ) < f 1 (x) since x is in the left subtree of η l , thus f (x) f (x l ) and f (x) f (x ).
The proof is similar for (2).

Proposition 3.1.3 is fundamental for the pruning process. It states that when x dominates η, then if a node η l (resp. η r ) in the left (resp. right) subtree of η:

• is dominated by x, then both η l (resp. η r ) and its whole right (resp. left) subtree are dominated, and thus can be removed.

• is not dominated by x, then x does not dominate any node in the left (resp. right) subtree of η l (resp. η r ).

The pruning process is implemented by the LeftPruning and RightPruning procedures. These procedures are symmetrical as the LeftPruning aims at pruning the left subtree of η and is initially called from l(η), while the RightPruning aims at pruning the right subtree of η and is initially called from r(η). Then, LeftPruning procedure is started from l(η) and follows a unique top-down path (indicated in bold edges) until reaching a leaf node. The procedure finally returns the node uη which is the deepest node to re-balance. The symmetrical process is performed in Θ(r(η)) via the RightPruning procedure but is not detailed.

Let us only describe the

Does x dominate

x(η l )?

Does η l has a left child?

Does η l has a right child?

yes no

• uη ← p(η l ) • delete Θ(η l ) no no η l ← r(η l ) yes • uη ← p(η l ) • delete η l & Θ(r(η l )) • reconnect p(η l ) with l(η l ) • η l ← l(η l ) yes Figure 3.4 -The LeftPruning procedure of an AVL-Archive called from a node η l ∈ Θ(l(η)) with a candidate solution x ∈ X.
Algorithme 13 : LeftPruning Input : calling node η l , deepest node to re-balance uη, candidate solution x Output : the deepest node to re-balance More precisely, the procedure explores Θ(l(η)) by following a single top-down path from the root of the subtree to a leaf node. Given Proposition 3.1.3, at each current node η l ∈ Θ(l(η)), only two cases are possible:

if f 1 (x) ≤ f 1 (x(η l )) then // x dominates both x(η l ) & Θ(r(η l )) uη ← p(η l ) if η l has a left
• If f 1 (x) ≤ f 1 (x(η l ))
, then x dominates η l and all nodes in Θ(r(η l )), thus they are removed if η l has a left child, then the subtree is recomposed by replacing η l by l(η l ) as child of p(η l ), and the search continues down in Θ(l(η l ));

otherwise, the search stops.

In both cases, the currently deepest node to re-balance is p(η l ) as the right subtree of η l has just been removed and thus can cause an imbalance from p(η l ).

• Otherwise, x does not dominate η l and any node in Θ(l(η l )), thus:

if η l has a right child, then the search continues in Θ(r(η l ));

otherwise, the search stops.

To summarize, at the end of the left and right pruning processes (independently performed), both left and right subtrees of η have been emptied of all dominated nodes and for each subtree, the deepest node to re-balance has been detected. All that remains to do is to re-balance both subtrees from their respective detected nodes (if necessary), then reconnect the subtrees to η, and finally re-balance the whole tree from η (if necessary).

Re-balancing process

The re-balancing process is called by the Add procedure in two distinct cases:

• once a new leaf node is inserted;

• once a node/subtree is deleted.

In any case, the deepest node affected by the modification is detected and re-balanced with a rotation if necessary. Because a rotation may propagate the imbalance on the ancestors of the node only (cf. [Adelson-Velskii, 1962, Knuth, 1998]), the tree is traveled up from this node and all imbalanced ancestors are rebalanced with rotations. The new root of the subtree affected by the rotation is λ.

η β(η) = ∆, ∆ ≥ 2 λ |β(λ)| ≤ 1 ρ β(ρ) ∈ {0, 1} Lλ Rλ
Lρ Rρ (a) An unbalanced subtree rooted at η. Subtrees Θ(λ), Lρ and Rρ are balanced.

A left rotation rooted at η is performed.

ρ β(ρ) ∈ {-1, 0} η β(η) ∈{∆-2,∆-1} λ |β(λ)| ≤ 1 Lλ Rλ Rρ Lρ (b)
The final balanced tree rooted at ρ. Algorithm 14 depicts a regular rotation rooted at a node η. The procedure performs a simple or a double rotation, if necessary, and returns the root of the affected subtree and a boolean indicating if a rotation has effectively been performed or not. It uses the LeftRotation and RightRotation procedures (the pseudocode of these procedures is straightforward and thus not given), which proceed to a simple left and right rotation, respectively, update the height and balance attributes, and return the root of the affected subtree. In any case (1)-( 4), after the rotation:

(I ) If ∆ = 2, then Θ is balanced, i.e. Property 3.1.2 is satisfied.

(II ) the archive is still a binary search tree, i.e. Property 3.1.1 is still satisfied.

Proof.

(1) The proof is illustrated by Figure 3.5. Let δ ∈ {0, 1} such that h(Rρ) = h(Lρ) + δ.

Before the rotation, the height of Θ is determined by the right subtree since the balance factor of the root is positive. Thus the height of Θ is equal to h(Rρ) + 2.

After the rotation, the height of Θ is equal to h(Lρ)+2 = h(Rρ)+2-δ, so the height of Θ has decreased or is unchanged. We have

β(η) = h(Lρ)-h(λ) = h(Lρ)-(h(Lρ)+δ +1-∆) = ∆-1-δ, so β(η) ∈ {∆-2, ∆-1}. We have β(ρ) = h(Rρ) -h(η) = δ -1, so β(ρ) ∈ {-1, 0}.
(2) This case is symmetrical to (1).

(3) The proof is illustrated by Figure 3.6. Let µ = l(ρ), Lµ = Θ(l(µ)), Rµ = Θ(r(µ)), max := max{h(Lµ); h(Rµ)} and min = min{h(Lµ); h(Rµ)}.

Before the rotation, the height of Θ is equal to max + 3. There is no assumption on the balance factor of µ, so (max -min) ∈ {0, 1}. We have h(µ) = max + 1 and given that

β(ρ) = -1, h(Rρ) = h(µ) -1 = max. Given that β(η) = ∆, we have h(λ) = h(ρ) -∆ = max + 2 -∆ thus h(λ) ≤ max since ∆ ≥ 2.
After the rotation, the height of Θ is equal to max + 2 < max + 3, so the height of Θ has decreased. Two cases appear:

• If we assume that h(Lµ) = max, then h(Rµ) = min and β(ρ) = h(Rρ) -h(Rµ) = max -min since h(Rρ) = max, so β(ρ) ∈ {0, 1}. We have also β(η) = h(Lµ) -h(λ) = ∆ -2 since h(λ) = max + 2 -∆. Moreover, β(µ) = h(ρ)-h(η) = (max+1)-(max+1) = 0 since h(η) = 1+max{h(Lµ); h(λ)} = max+1 because h(λ) ≤ max. • Otherwise, if h(Lµ) = min, then h(Rµ) = max and β(ρ) = max -max = 0 since h(Rρ) = max.
We have also

β(η) = h(Lµ) -h(λ) = min -max -2 + ∆ since h(λ) = max + 2 -∆, so β(η) ∈ {∆ -3, ∆ -2}. Moreover, β(µ) = h(ρ) -h(η) = (max + 1) -(1 + max{h(Lµ); h(λ)}) ∈ {0, 1} since max{h(Lµ); h(λ)} ∈ {min, max} because h(λ) ≤ max. So β(η) ∈ {∆ -3, ∆ -2} and β(µ) ∈ {0, 1} in both cases.
(4) This case is symmetrical to (3).

(I) Obvious from proofs of ( 1) and ( 3). See [Adelson-Velskii, 1962] for another proof.

(II) Obvious from Definitions 3.1.2, 3.1.3, 3.1.4 and 3.1.5.

Proposition 3.1.4 distinguishes four distinct cases of imbalance, and to each case is assigned a specific rotation.

Let us first consider the insertion case, in which a new node η new is inserted in the tree after a candidate solution incomparable with all the solutions of the archive has been accepted. This case is already supported by the original AVL-tree algorithm [Adelson-Velskii, 1962] and the pseudo-code is depicted in Algorithm 15:ReBalanceAfterInsert. This method travels up the tree starting from the parent node η = p(η new ) and searches the first unbalanced descendant of η new . As the absolute balance factor of any node is maintained inferior or equal to 1, the absolute balance factor of such a node is 2. A single rotation rooted at this node is then performed and re-balances the whole affected subtree, given Proposition 3.1.4. Given [Adelson-Velskii, 1962], the insertion of a new node unbalances at most one descendant, thus the search stops once such a descendant has been re-balanced. Moreover, the search can be prematurely stopped if the balance factor of the current visited descendant is null. Now consider the deletion case. As previously suggested in Section 3.1.1.2, when a candidate solution dominates a node η:

• Both left and right subtrees of the dominated node Θ(l(η)) and Θ(r(η)) are first disconnected to η, then pruned, and the deepest node to re-balance of each subtree is identified. For each subtree: if one node at least has been removed, then the deepest node to re-balance uη and any of its ascendants might be unbalanced; thus a re-balancing procedure is called from uη.

• Once these subtrees have been reconnected to η, if one node at least has been removed from one of the subtrees, then η and any of its ascendants might be unbalanced; thus a re-balancing procedure is called from η.

Because whole subtrees can be removed during the pruning process, the absolute balance factor of a number of nodes may exceed 2. To our knowledge, such serious imbalance has not been taken into account by the original re-balancing procedure of AVL-tree, thus we generalized it.

The generalized re-balancing procedure works as follows. Let η be the node to re-balance. Algorithm 16 presents a rotation chain starting from a node η. First, the root of the subtree after the first rotation is memorized as it is the root of the subtree once the rotation chain is finished. Then, the imbalance is iteratively pushed down. The method returns the new subtree root . Note that if η is initially balanced, the subtree is unchanged.

Proposition 3.1.5. Let Θ(η) be a tree rooted at η such that |β(η)| = ∆, ∆ ≥ 2 and both Θ(l(η)) and Θ(r(η)) are balanced. If a rotation chain is performed from η, then Θ(η) is balanced after applying at most ∆ -1 rotations (i.e. Property 3.1.2 is satisfied).

Proof. This result is a direct consequence of Proposition 3.1.4. As a rotation strictly improves the absolute balance factor of η of at least 1, then a rotation chain always terminates after at most ∆ -1 rotations so that |β(η)| ≤ 1 and the whole tree is balanced. Algorithm 17:ReBalanceAfterDelete implements the generalized re-balancing procedure starting from a node η. The procedure travels up the tree from η and applies a rotation chain to each ascendant. Any ascendant can be unbalanced after a deletion, thus the search cannot be prematurely stopped (as in the insertion case) until reaching the root of the tree. Proof. Given that an AVL-Archive is a balanced binary search tree, its height is in O(log 2 s). Let x be the candidate solution presented to the archive.

First, a dichotomic search is performed from the root to a node η. For each traversed node, constant time operations are performed.

• If x(η) weakly dominates x, then the procedure is stopped. Therefore in this case, the complexity is in O(log 2 s).

• Otherwise, if x is incomparable with all traversed node, then a new node is created with x as solution.

During the re-balancing process, the tree is traveled up from η and at most one rotation is performed, which is a constant time operation. Thus in this case, the complexity is in O(log 2 s).

• Otherwise, x dominates x(η). Both left and right subtrees of η are pruned. During the pruning process, a single path is followed and for each traversed node, the operations are made in constant time, including the deletion operation. So the pruning process is also in O(log 2 s).

Concerning the re-balancing process, let us consider the worst case, which consists in re-balancing a tree formed by a path of O(log 2 s) nodes. Now assume that the deepest node to re-balance uη is the last node, i.e. the unique leaf of the tree. The re-balancing process consists in traveling up the tree from uη to the root, and thus traversing O(log 2 s) nodes. For each traversed node: a rotation chain is applied, performing at most ∆ -1 rotations, where ∆ ∈ O(log 2 s) is the balance factor of the starting node of the rotation chain. Thus the re-balancing process is in O(log 2 2 s).

Self-adjusting version

The Self-Adjusting version of an AVL-Archive, called SAAVLA, has a number of additional features compared to the vanilla version.

First, in addition to its usual attributes, a node η is associated with the local ideal z * (η) of the subtree rooted at η defined such that:

z * j (η) = min{f j (x(η )) : η ∈ Θ(η)} for j = 1, 2 In fact, z * 1 (η) (resp. z * 2 (η)
) is the first (resp. second) objective value of the solution contained in the left-most (resp. right-most) node of Θ(η). The local ideal z * (η) is updated online and we do not mention these updates in pseudo-code as they are trivial. Indeed, each time a leaf is created or deleted:

• if this leaf is a left child: the first objective value of its associated solution is propagated upward and is used to update z * 1 (η ), for each one of its ascendant η .

• if this leaf is a right child: the second objective value of its associated solution is propagated upward and is used to update z * 2 (η ), for each one of its ascendant η .

(110, 38) ?

4 z 2 z 6 z 1 z 3 z 5 z 7
(a) The archive (stored points are indicated in nodes). A SAAVLA maintains a so-called cache node, which is:

f1 f2 • z 1 • z 2 • z 3 • z 4 • z 5 • z 6 • z 7 (z 1 1 , z 7 2 ) (z 1 1 , z 3 2 ) (z 5 1 , z 7 2 ) (b)
• either the node which has rejected the last candidate solution;

• or the parent of the new node containing the last candidate.

When a new candidate solution is presented to the archive, instead of performing a dichotomic search from the root, it starts from the cache node. The general idea is that if a locality assumption holds, then two consecutive candidates will probably be either accepted or rejected in the same subtree. Starting from the cache node prioritizes the previously explored subtree.

However, an issue occurs with this mechanism. Let η be the cache node and x ∈ X be the current candidate solution. Thus the search starts from the cache node, but it may happen that x is weakly dominated or even dominates a node outside the subtree rooted at the cache node.

Next we introduce important notions to address this issue.

Definition 3.1.6. A relevant subtree Θ(η) w.r.t. a solution x ∈ X is a subtree such that:

1. x can not dominate any node outside the subtree;

2. and if a node outside the subtree weakly dominates x, then a node inside the subtree also weakly dominates x for sure.

A relevant subtree corresponds to a subtree from which a dichotomic search can be effectively started, because the acceptance/rejection process is not influenced by nodes outside the relevant subtree. Let us now present some propositions supervising the notion of relevant subtree.

Proposition 3.1.7. Let η, η be two nodes. η ∈ Θ(η) iff. z * (η) f (x(η )).
Proof. Obvious from the combination of Property 3.1.1 and Proposition 3.1.1.

Proposition 3.1.8. Let x ∈ X be a candidate solution external to the archive and η be a node. If

z * (η) f (x), then ∀η / ∈ Θ(η), f (x) f (x(η )).
Proof. Let us assume that the proposition is incorrect. So there is a node

η / ∈ Θ(η) such that f (x) ≤ f (x(η )), thus z * (η) ≤ f (x(η ) since z * (η) f (x)
. This is contradictory with the fact that η / ∈ Θ(η) given Proposition 3.1.7. Proposition 3.1.9. Let x ∈ X be a candidate solution external to the archive and η be a node. If

z * (η) f (x) and ∃η / ∈ Θ(η) s.t. f (x(η )) f (x), then ∃η ∈ Θ(η) s.t. f (x(η )) f (x). Proof. Let z L ∈ Y be the point stored in the left-most point of Θ(η), i.e. st. z * 1 (η) = z L 1 , and z R ∈ Y the point stored in the right-most node of Θ(η), i.e. st. z * 2 (η) = z R 2 . (i) If f 2 (x(η )) < z R 2 , thus z R 1 < f 1 (x(η )) since f (x(η )) z R . Moreover, z R 1 < f 1 (x) since f (x(η )) f (x). Thus z R f (x) since z R 2 = z * 2 (η) f 2 (x). (ii) Otherwise, f 1 (x(η )) < z L 1 since η / ∈ Θ(η).
The remaining of the proof is similar to (i) and we finally obtain that z L f (x).

Instead of starting immediately a dichotomic search from the cache node, we travel up the tree until reaching an ascendant η of the cache node (including itself) such that z * (η) f (x). In this case, given Propositions 3.1.8 and 3.1.9, we are located in a so-called relevant subtree w.r.t. x, thus a dichotomic search is started from η.

Algorithme 18 : SAAVLA::Add Input : candidate solution x Output : boolean

η ← CacheNode() while p(η) = ∅ do if z * (η) f (x) then return Add(η, x) η ← p(η) return Add(η, x)
Algorithm 18 describes the revised Add procedure of SAAVLA. First we search for the relevant subtree w.r.t. the candidate solution x. Once this node is found, we proceed to the vanilla version of the Add procedure.

NDR*-Archive

A R * -tree [Guttman, 1984, Beckmann et al., 1990] is a spacial indexing tree data structure used for indexing spatial objects (like hyper-rectangles, hyper-spheres or more complex objects) in a multi-dimensional space. This data structure is extensively based on the notion of MBB. First, by ease of simplicity and to avoid costly geometrical computations, each object stored in a R * -tree is instead represented by its own MBB, i.e. the MBB completely covering its particular shape. Second, a R * -tree can be seen as a hierarchy of MBBs, such that:

o 1 o 6 o 2 o 3 o 4 o 5 o 7 R A B R A B o 1 , o 2 , o 5 , o 6 o 3 , o 4 , o 7
Figure 3.10 -Example of R * -tree in two-dimensional space containing seven spatial objects distributed into two leaves A and B, themselves contained in the root node R.

• A leaf node contains a list of objects. All the objects stored in the R * -tree are partitioned among the leaves, such that nearby objects tend to be in the same leaf node. To a leaf is attached a MBB including all the objects stored by this leaf.

• An internal node contains a list of child nodes. In the same way as a leaf, to an internal node is attached a MBB including all the MBB of its children.

Figure 3.10 shows a R * -tree. As a spatial indexing data structure, a R * -tree aims at providing fast answers to online queries such as searching, inserting or removing a number of indexed objects.

Since all the objects contained in a node lie within the attached MBB, a query that does not intersect the MBB cannot intersect any of the contained objects. This way, when a query is performed, a Depth First Search (DFS) is executed from the root of the tree and explores only the children whose MBB is concerned by the query.

A R * -tree has two main additional properties. First, it is a balanced k-ary tree, meaning that at any time, all leaves are at the same depth. Second, the nodes have a fixed minimum and a fixed maximum children/objects list size. The data structure is managed such that three main criteria are minimized: the total hypervolume, the margin (corresponding to the sum of the length of the edges) of the MBBs, and the overlap between the MBBs.

When an internal node (resp. leaf) is overfilled after the insertion of a new object, two strategies are successively considered. The first one, called extraction strategy, is to extract from the children (resp. list) of the overfilled node a number of nodes (resp. objects) and reinsert them like regular new objects. The idea behind this strategy is that the extracted objects might be re-inserted in a more suitable node of the tree.

The second one, called splitting strategy, aims at splitting the overfilled node into two new nodes. Globally, the splitting strategy is used on a node when the extraction strategy has failed.

Once a node is underfilled, it is removed from the tree and its children/objects are reinserted.

R * -trees do not guarantee good worst-case performance, but generally perform well with real-world data [START_REF] Hwang | Performance evaluation of main-memory r-tree variants[END_REF].

Unfortunately, we found that adapting directly the R * -tree structure for archiving task provides extremely poor results compared to the state-of-the-art archive ND-Tree. This first failure led us to the idea of combining these two structures into a new one attempting to retain the strengths of both structures and trying to lessen their weaknesses. We call this new archive NDR * -Archive.

Design of NDR * -Archive

The NDR * -Archive combines features of ND-tree and R * -tree. Each one of these two data structures has its own strengths and weaknesses:

• ND-tree has been specially designed for archiving, as outlined in Section 2.4.4. On the other hand, it is not a balanced tree, allowing a low structure maintenance cost.

• R * -tree has not been designed for archiving. On the other hand, it is a balanced tree at the expense of a high structure maintenance cost. Another drawback of a R * -tree is that it is complex to implement, in particular because it is itself an upgrade of R-tree [Guttman, 1984] to which several new features have been added.

NDR * -Archive is, globally, a simplified and modified, archiving-adapted R * -tree using the theoretical properties of ND-tree (reviewed in Section 2.4.4) to manage efficiently a set of incomparable points, but including also new features.

NDR * -Archive works as follows. Each node η maintains:

• an approximate local ideal ideal(η) and nadir nadir(η) points, defining a bounding box including all the points stored in the subtree;

• a list of its children children(η) if it is internal, and a list of solutions solutions(η) if it is a leaf.

Let an object be either a node or a solution. Like R * -tree, the nodes have a fixed minimum and a fixed maximum children/solutions list size. The process of NDR * -Archive is driven by two main procedures: the Add solution procedure and the Restructure tree procedure.

The Add solution procedure

Algorithme 19 : Add Input : candidate solution x Output : boolean

dominated ←CheckDominance(root, x) if dominated then return false N in ← ∅; X in ← {x} Prune(root, x, N in , X in ) foreach η in ∈ N in do ReInsert(root, η in , prevDepth(η in ) -1, 0) foreach x in ∈ X in do ReInsert(root, x in ,leafDepth() -1, 0) return true
The Add solution procedure is the core of NDR * -Archive. It is described with a diagram in Figure 3.11 and detailed in pseudo-code by Algorithm 19: Add. This procedure is activated when a new candidate solution x is presented to the archive. It works as follows:

(1) First, one checks if x is dominated by exploring the archive in DFS starting from the root (Algorithm 20: CheckDominance). For each node met, if x is not weakly dominated by the local ideal, then x is not

(1) Check dominance: explore the archive in DFS while x is not weakly dominated.

foreach x ∈ solutions(η) do if f (x ) f (x) then return true
return false dominated by any point in the subtree; otherwise, if the local nadir does not weakly dominate x, then the search continues down in the subtree while x is not proved to be dominated. Note that this procedure just checks if x is dominated, so it makes only one-sided comparisons between x and the objects of the tree.

(2) If x is accepted, then no solution in the archive weakly dominates x. In this case, the tree is pruned by removing dominated nodes and solutions through the exploration of the archive in DFS starting from the root (Algorithm 21: Prune).

More precisely, for each node met, if x does not weakly dominates the local nadir, then x does not dominate any point in the subtree; otherwise, if the local ideal is weakly dominated by x then all the points in the subtree are dominated by x, so the node is removed. Otherwise, the search continues down in the subtree and any dominated object or empty node is removed. If a node is underfilled after the deletion of some of its children/solutions, then its children/solutions are memorized in a list (called the memorized objects for the rest of this section), then the node is removed.

When a child node cη is removed, the UpdateIdealNadir(η, {cη}, -) procedure is called from its parent η.

The procedure UpdateIdealNadir(η src , N modif , option) updates the approximate local ideal and local nadir of the node η src considering the deletion of (option = -), the inclusion of (option = +) or the reset with (option = * ) the set of nodes N modif . The procedure also updates accordingly the local ideal and local nadir of the ascendants of η src . In order to reduce the maintenance cost, this procedure is not called when a solution is removed.

(3) When all dominated objects have been removed, then the candidate solution and the memorized objects are (re)inserted in the tree (Algorithm 22:ReInsert).

Let the hypervolume of a node be the hypervolume of the bounding box defined by its approximate local ideal and local nadir points.

To reinsert each memorized object, the tree is explored by following a simple top-down path starting at the root; for each node met, the child for which the insertion of the object minimizes the hypervolume enlargement is selected. Then, the procedure is recursively called from this child. If the object is a solution, then it is (re)inserted in a leaf; otherwise, if the object is a node, then it is reinserted at the same tree depth than before its memorization (in order to preserve the structure of the tree). At the end, the approximate local ideal and local nadir of the parent node are updated. Note that the minimization of the hypervolume at each level of the tree is crucial in the sense that it corresponds to a minimization of the dead space between the MBBs of the nodes; and reducing this dead space helps reducing the height of the tree. Finally, the Restructure tree procedure is activated to re-structure the tree from the parent node.

foreach cη ∈ children(η) do if Prune(cη, x, N in , X in ) then children(η) ← children(η) \ {cη} UpdateIdealNadir(η, {cη}, -) delete cη if η is underfilled then N in ← N in + children(η) children(η) ← ∅ else // η is a leaf foreach x ∈ solutions(η) do if f (x) ≤ f (x ) then solutions(η) ← solutions(η) \ {x } delete x if η is underfilled then X in ← X in + solutions(η) solutions(η) ← ∅ return (η is empty) Algorithme 22 : ReInsert Input : calling node η, node/solution to reinsert ω, reinsertion depth rδ, current depth δ Output : ∅ if δ < rδ then cη * ← arg min{Hypervolume(cη + ω) -Hypervolume(cη) : cη ∈ children(η)} ReInsert(cη * , ω, δ + 1) else // δ = rδ if η is internal then children(η) ← children(η) + ω else // η is a leaf ⇒ ω is a solution solutions(η) ← solutions(η) + ω UpdateIdealNadir(η, {ω}, +) RestructureTree(η)

Restructure tree procedure Algorithme 23 : RestructureTree

Input : calling node η Output : ∅ if η is overfilled then η ←Split(η) if η = root then pη ← parent(η) children(pη) ← children(pη) + η RestructureTree(pη) else // η = root ⇒ ascend root root ←new node() children(root) ← η + η UpdateIdealNadir(root, η + η , *)
The Restructure tree procedure is described with a diagram in Figure 3.12 and detailed in pseudo-code by Algorithm 23: RestructureTree. Let η be the node from which the procedure is called. If η is overfilled, then it is split. The split procedure is a key component of NDR*-Archive. It aims at partitioning into two subsets the children/solutions of a node. R*-tree split manages MBBs of spatial objects while ND-tree split manages points. On the other hand, NDR * -Archive faces both cases: it has to split internal nodes, such that children are nodes represented by their bounding boxes; and it also has to split leaves, containing points. Two different splits are considered for each case. The main difference between the internal node splits and the leaf splits is the split fitness to optimize.

Algorithme 24 : Split (I1) Input : calling internal node η Output : new node η max, min ←maximum, minimum storage capacity of children(η)

SplitFitness(•, ••) ← lex {Overlap(•, ••), Hypervolume(•) + Hypervolume(••)} // Compute the best partition: (N * 1 , N * 2 ) ← ∅ for j = 1, ..., p do foreach optimum ∈ {ideal(η), nadir(η)} do (cη 1 , ..., cη max+1 ) ←Sort children(η)
in ascending order by the j-th objective value of their optimum

for k = min, ..., max -min + 1 do N 1 ← (cη 1 , ..., cη k ) N 2 ← (cη k+1 , ..., cη max+1 ) (N * 1 , N * 2 ) ← arg min{SplitFitness(N * 1 , N * 2 ); SplitFitness(N 1 , N 2 )} // Update η: η ←new node() children(η) ← N * 1 ; UpdateIdealNadir(η, N * 1 , *) children(η ) ← N * 2 ; UpdateIdealNadir(η , N * 2 , *) return η
The first internal node split (Algorithm 24: Split (I1)) we proposed, called split I1 , is a simplified version of the R*-tree split. Globally, given an internal node to split, the idea is to select a partition of its children depending on a splitting objective which minimizes the overlap between the two resulting subsets.

More precisely, let η be the internal node to split. The computation of the best partition of the children of η iterates both on: (i) the objectives (j = 1, ..., p) considered alternately for sorting the children of η; (ii) the local optima of any child node (ideal, nadir) used as sorting key. The split axis is the current objective selected for sorting.

Let j ∈ {1, ..., p} be the index of the current split axis, and optimum ∈ {ideal, nadir} the current optimum. First, the children are sorted by their optimum's j-th objective value. Any partition such that both subsets contain only consecutive children given the current sorting, and is neither underfilled nor overfilled is considered. We look for the partition minimizing the overlap between the bounding boxes of its two subsets; ties are resolved by choosing the partition such that the hypervolume sum of the bounding boxes of its subsets is minimum.

Note that minimizing the overlap is of prime importance because it has a deep impact on the number of paths to be traversed when a solution is presented to the archive.

The first leaf node split we designed, called split L1 , works similarly than the split I1 by choosing the axis and the corresponding partition minimizing a given fitness; except for two differences: the objective values of the solutions are considered for sorting, and the fitness used to evaluate a partition is the distance between the center of its two subsets (to maximize), instead of the overlap. We still search for minimizing the hypervolume in case of tie. We found that using either the Manhattan or the Euclidean distance provides similar results. Globally, the idea behind this split is to maximize the gap between the two resulting subsets.

Algorithme 25 : Split (L2) Input : calling leaf node η Output : new node η max ←maximum storage capacity of solutions(η) // Compute the best partition:

(x 1 , x 2 ) ← arg max{Distance(x, x ) : x, x ∈ solutions(η)} solutions(η) ← solutions(η) \ {x 1 , x 2 } X 1 ← {x 1 } ; X 2 ← {x 2 } while solutions(η) = ∅ and X 1 < max and X 2 < max do x ← arg min{min{Distance(x , center(X 1 )); Distance(x , center(X 2 ))} : x ∈ solutions(η)} solutions(η) ← solutions(η) \ {x} if Distance(x, center(X 1 ) < Distance(x, center(X 2 )} then X 1 ← X 1 + x else X 2 ← X 2 + x if X 1 < max then X 1 ← X 1 + solutions(η) else X 2 ← X 2 + solutions(η) // Update η: η ←new node() solutions(η) ← X 1 ; UpdateIdealNadir(η, X 1 , *) solutions(η ) ← X 2 ; UpdateIdealNadir(η , X 2 , *) return η
The second internal node split, called split I2 , is mainly based from the split used by R-trees. Contrary to I1, it considers all the objectives at the same time and try to minimize the total hypervolume of the new partition.

More precisely, it first selects the pair of child nodes such that the dead space between their MBBs is maximal, each one is extracted from the split node and inserted in two different subsets. Then, while the split node has a child and the two subsets are not overfilled, the child node minimizing the hypervolume enlargement through its insertion in any of the two subsets is selected. This node is extracted from the list of children of the split node and inserted in the best subset. Finally, if a subset is full, the remaining children of the split node are inserted in the other subset.

The second leaf node split, called split L2 , works in a similar way as split I2 except that the fitness used is the (Euclidean) distance between a point and the center of a subset (to minimize). Indeed, using the hypervolume enlargement as fitness did not provide good results for this leaf split. Algorithm 25 describes split L2. Globally, this split has some similarities with the split used in ND-Tree.

Independently to the split used, once the best partition has been found, the nodes of the second group are extracted (from the split node η) to a new node η .

Finally, the same restructure tree procedure is restarted from the parent of η. Note that if the overfilled node η is the root of the archive (cf. lines 7-10 of Algorithm 23), the root is ascended, meaning that a new root is created and takes as children the old root and the new node created by the split. This mechanism increases by one the height of the tree. This last step concludes the description of the NDR * -Archive. Figure 3.13 illustrates an example of insertion of a non-dominated candidate solution in a NDR * -Archive.

Self-adjusting version

Algorithme 26 : Add: modifications for self-adjustment.

// Replace the instruction line 1 in Algorithm 19 by the following // instructions to implement a self-adjusted NDR * -Archive:

η ← cacheNode(root) repeat dominated ← CheckDominance(η, x) η ← parent(η)
until dominated or η =none;

The proposed upgrade for self-adjustment of NDR*-Archive is general and goes beyond the archiving case. Indeed, it enables any R-like tree to use locality assumption, even for regular indexing tasks. Two main features characterize this upgrade:

1. We memorize the so-called cache node, from which the last candidate solution has been either inserted or rejected. Then, when a new candidate solution is presented to the archive, we start the CheckDominance procedure from the cache node instead of the root of the archive. When the subtree has been explored and the candidate solution not rejected, then the CheckDominance procedure is called from the parent of the cache node. This process continues until the candidate is rejected or the root is reached. Note that we forbid a subtree to be explored twice. Algorithm 26 indicates the instructions replacing the first instruction of the Add procedure (Algorithm 19):

dominated ← CheckDominance(root,x)
to handle self-adjustment, where root is the root of the archive and x is the current candidate solution.

2. When the candidate is either inserted or rejected, all the nodes and the single solution (in a potential leaf) on the insertion/rejection path are then positioned in first position.

We call this archive SANDRA, standing for Self-Adjusting NDR*-Archive. As shown by our experiments reported in the next section, these simple modifications lead to substantial computational time improvements.

Figure 3.14 describes two use case examples of SANDRA.

• • • • • • • • • R A B a 1 a 2 b 1 b 2 R A B a 1 a 2 b 2 b 1 (a)
Step 1: The new solution is inserted into the leaf a 2 by calling ReInsert from the root node R.

• • • • • • • • • R A B a 1 a 2 a 2 b 1 b 2 R A B a 1 a 2 a 2 b 2 b 1 (b)
Step 2: After the insertion, the leaf a 2 is overfilled, so it is split by calling Split from a 2 . A new node a 2 containing two solutions is created and inserted into A.

• • • • • • • • • R A a 1 a 2 B a 2 A b 1 b 2 R A A B a 1 a 2 a 2 b 2 b 1 (c)
Step 3: After the split of a 2 , A is overfilled. So A is split and a new node A containing a 2 is created and inserted into R. We assume that x has already been checked for non dominance; and that internal and leaf nodes can contain at most two elements and at least one element.

• • • • • • • • • Q R A a 1 a 2 B a 2 R A b 1 b 2 Q R R A A B a 1 a 2 a 2 b 2 b 1 (d) Step 4: After the split of A, R is overfilled. So R is ascended: it is split and a new node R containing B is created. A new root Q is created

Experiments

AVL-Archive, NDR * -Archive and their self-adjusting versions (SAAVLA, SANDRA) are experimentally compared to the current best known archives: ND-Tree [START_REF] Jaszkiewicz | Nd-tree: a fast online algorithm for updating a pareto archive and its application in many-objective pareto local search[END_REF] (for any number of objectives p) and sorted list (for p = 2 only). In particular:

1. AVL-Archive, NDR * -Archive, ND-Tree and sorted list are compared on a benchmark of several artificial sets simulating the generation of points during the run of a meta-heuristic;

2. AVL-Archive, SAAVLA, NDR * -Archive, SANDRA, ND-Tree and sorted list are applied within PLS on MOTSP.

All experiments presented were performed on a 3.4 GHz computer with 16Gb of volatile memory (RAM) on a Linux OS. All algorithms are written in C/C++. We use the C/C++ ND-Tree implementation of Jaszkiewicz and Lust and a slightly improved version of the sorted list they implemented. The linear list has been implemented with the Move-to-Front heuristic [START_REF] Bentley | Fast linear expected-time algorithms for computing maxima and convex hulls[END_REF].

Splits C child max C solution max R min I1+L1 p + 6 20 45% I1+L2 p + 1 I2+L1 p + 6 30% I2+L2 p + 2 25%
Table 3.1 -Good parameter settings for NDR * -Archive with different split combinations.

Artificial sets

Given p objectives to minimize, an artificial set is composed of N nd non-dominated points, and N dom = φ dom × N nd dominated points, where φ dom ≥ 0. Let us now describe how an artificial set of points is created. Any point y = (y 1 , ..., y p ) ∈ N p is generated uniformly at random in {0, ..., R} p inside a hyperball of center (R, ..., R) and radius R, such that p j=1 (R -y j ) 2 ≤ R 2 . The idea is to obtain points near the corresponding hypersphere and not near the point (0, ..., 0). In order to control the dispersion of the points generated, the constraint

p j=1 (R -y j ) 2 ≥ (1 -ε) × R 2 is added, where ε ∈ [0, 1].
With a small ε, we obtain a dense set of points close to the hull of the hypersphere; while a large ε generates a scattered set of points.

This way of generating a set of points proposed in [START_REF] Jaszkiewicz | Nd-tree: a fast online algorithm for updating a pareto archive and its application in many-objective pareto local search[END_REF] simulates well the behavior of a multi-objective heuristic. Unfortunately, with this methodology, we can not control a fundamental parameter: the proportion of dominated points φ dom , computed as the number of dominated points divided by the number of non-dominated points. As we will see later, the archiving time greatly depends on this parameter. We proceed in two steps to generate in the hyperball, a set of points with N nd non-dominated points and N dom dominated points.

During the first step, we successively generate points uniformly at random in the hyperball and present each one to an archive, until N nd incomparable points are finally obtained.

The second step produces the dominated points. To do so, we successively generate points uniformly at random in the hyperball and each one is accepted only if it is dominated by a point in the archive. We stop when N dom dominated points have been produced. Contrary to the first step, this second step is computationally expensive in the sense that it is relatively similar to the approximation with Monte Carlo sampling of the hypervolume indicator value [Zitzler, 1999] of the archive obtained in the first step. Thus, we speed-up the second step using a kd-tree [Bentley, 1975] we have modified to be dynamic and able to handle uniform sampling. The resulting list of solutions can then be presented to an archive.

To summarize, given that the hyperball radius is set to R = 1000000, an artificial set is defined by: the number of objectives p, the parameter ε controlling the dispersion of the points, the number of non-dominated points N nd , and a proportion of dominated points φ dom controlling the number of dominated points (in function of the number of non-dominated points). ) is the minimum storage capacity of child (resp. solution) list.

Split and parameter setting of NDR

Four different splits have been proposed for NDR * -Archive. A good parameter setting has been found for each one of the four possible combinations of splits I1+L1, I1+L2, I2+L1 and I2+L2. The chosen parameter settings are indicated in Table 3.1 and Figure 3.15 shows the influence of different parameter settings for NDR * -Archive with the split combination I1+L1. Globally, the split I1 needs a high R min while I2 needs a low R min ; and L1 works better when C child max is large, whereas L2 seems to favor a low C child max . For all combinations and number of objectives, a C solution max set to 20 obtains good results.

For each number of objectives p = 2, 3, 4, 5, we tested the different combinations of splits (with their previously proposed settings) by comparing them on a benchmark of artificial sets with intermediate parameter values: a spread of points ε = 15%, N nd = 30000 non-dominated points and a proportion of dominated points set to φ dom = 10. Results are indicated in Figure 3.16. The split L1 seems to be particularly efficient and the best combination of splits appears to be I1+L1.

Experiments on artificial sets

The benchmark of artificial sets we propose for comparing AVL-Archive, NDR * -Archive, ND-Tree and sorted list is composed of 1600 (= 80 × 20) instances of 80 different types where each instance contains between 10 thousands and 50 million points. Each type is defined by the following instance parameters:

• number of objectives p = 2, 3, 4, 5

• dispersion of points ε = 5%, 25%

• number of non-dominated points N nd = 10000, 50000

• number of dominated points N dom = φ dom × N nd where φ dom = 0, 1, 10, 100, 1000

For each type of instance (i.e. for each combination of instance parameters), 20 different instances are randomly generated.

The case φ dom = 0, i.e. when there is no dominated points, generally does not occur in a real-world application, but it allows us to compare how efficient in time are the building mechanisms of the different archives. Note that the upper bound of the interval proposed for φ dom is still realistic since, as we will see later when running a meta-heuristic, the number of generated dominated points is generally much larger than the number of non-dominated points.

Results are presented in Tables 3.2, 3.3, 3.4 and 3.5. The different archives (second columns) are compared in terms of number of comparisons (third column) and computational time (fourth column) in function of the proportion of dominated points (first column). The number of comparisons (third column) indicates the average number of dominance comparisons made between a candidate and the solutions/nodes of an archive so as to accept or reject the candidate. Figure 3.17 shows a computational time comparison between the different archives in function of the proportion of dominated points, for any number of objectives.

For p = 2, AVL-Archive outperforms all the other archives and NDR * -Archive performs better than ND-Tree, particularly when the number of dominated points is a hundred times or more larger than the number of non-dominated points; in this case, NDR * -Archive is often at least twice faster than ND-Tree. The sorted list remains slower than AVL-Archive, even when φ dom is high. NDR * -Archive and particularly ND-Tree, are outperformed by the sorted list and AVL-Archive in terms of average number of dominance comparisons.

For p ∈ {3, 4}, NDR * -Archive performs better than ND-Tree, especially when φ dom grows. Globally, when there is as many dominated points than non-dominated points, NDR * -Archive is 27% faster in average than ND-Tree, while NDR * -Archive is at least twice faster than ND-Tree when φ dom = 1000.

For p = 5, NDR * -Archive remains better than ND-Tree, and particularly when φ dom is high, but a stagnation in terms of performance improvement is observed. Indeed, in average NDR * -Archive is approximately 50% faster than ND-Tree.

This stagnation can be explained by the following analysis. When a candidate is presented to NDR * -Archive, the tree is explored a first time and comparisons are oriented to check if the candidate is dominated. If it is not dominated, the tree is explored a second time and comparisons are made with the sole aim to remove dominated nodes or solutions. We say that NDR * -Archive makes one-sided comparisons. Thus, with such a separation of processes, some parts of the tree will be explored twice if the candidate is finally accepted. On the other hand, computationally light comparisons are made if the candidate is dominated. This is one of the new features we introduced. On the contrary, ND-Tree makes complete comparisons for checking if the candidate is either dominated or dominating, during the same exploration of the tree. Yet, for fixed N nd , φ dom and ε, the number of accepted candidates tends to increase considerably when p grows (see Figure 3.18(a) as illustration). Consequently, the number of dominance comparisons induced by accepted candidates increases much more for NDR * -Archive than for ND-Tree. Figure 3.18(b) illustrates this trend by indicating the number of comparisons made by NDR * -Archive and ND-Tree for rejected and accepted candidates, in function of the number of objectives p. In order to prevent this issue, a modification of NDR * -Archive would be to explore only once the tree, like ND-Tree. However, this would make more expensive the checking of dominated candidate. We expect the same trend for PLS (Section 3.3.4).

Despite all that, NDR * -Archive remains more efficient than ND-Tree, even when all candidates are nondominated (φ dom = 0), and particularly for p ≤ 4. This efficiency is due to the following reasons:

1. Comparisons made by NDR * -Archive are one-sided and thus low-cost, contrary to ND-Tree.

2. According to Section 3.3.2, the splits I1 and L1 used by the NDR * -Archive are more efficient than the other splits generally used in other structures.

3. The dynamic structure of NDR * -Archive allows it to replace previously removed parts of the tree to re-balance it (in other words, the archive can fill the holes), which is a mechanism absent in ND-Tree, making NDR * -Archive more compact than ND-Tree. Indeed, an interesting quality criterion measuring the compactness of structures used in the indexing structure research field is the storage utilization of nodes computed at the end of the candidate insertions. The storage utilization of a tree is measured by computing the ratio between the current number of child nodes and solutions stored in the tree, and the total number of available slots of child nodes or solutions. Globally, the storage utilization of NDR * -Archive is around 50% while for ND-Tree it is around 30%. (d) ε = 25%, N nd = 50000

Table 3.5 -Performance of archives for p = 5.

Note that the RAM utilization of both structures is, in average over all tested instances, linear in the number of solutions stored.

Experiments on PLS

The second bench of experiments tests the use of archives inside PLS, applied to MOTSP. As previously noted in Section 2.2.3.5, the quality of the starting solution set is of prime importance for the convergence speed of PLS. Thus, instead of producing a starting set of solutions randomly generated, we follow the 2PPLS framework (Algorithm 7) which is standard nowadays:

• We first generate an initial approximation of the efficient set by solving a number of single-objective TSP through a linear aggregation of the objectives and a pre-defined set of weights using MDW [Steuer, 1986]. Each single-objective TSP is optimized using the chained Lin-Kernighan heuristic [START_REF] Applegate | Chained lin-kernighan for large traveling salesman problems[END_REF]]. Then we start PLS from this initial set of solutions.

• The neighborhood used in PLS is a 2-opt with complete exploration strategy and candidate lists, such that an edge is candidate only if it composes a solution of the starting set of PLS.

Let us first introduce the MOTSP instances considered, then describe the experimental methodology and the different archives tested.

Benchmark instances

The benchmark is composed of 240 (= 3 × 4 × 20) MOTSP instances of 3 different sizes n for each number of objectives p = 2, ..., 5. Each instance has been generated with the same construction processes as in the literature ( [Reinelt, 1991, Lust and[START_REF] Lust | [END_REF]):

• An instance is composed of p single-objective Euclidean instances

• For each objective, the coordinates of each city are integers that are uniformly and independently generated in the range [0; 3163], and the costs between the edges correspond to the Euclidean distance between two cities on the plane.

For each combination of size and number of objectives, 20 instances are randomly generated.

Note that the size of the instances has been substantially reduced according to the number of objectives because the number of incomparable points generally increase significantly with a growing number of objectives.

Experimental methodology and results

As indicated in Section 2.2.3.5, two sub-versions of PLS have been proposed:

• the original version (without local archive);

• the version with local archive.

We propose to compare these two sub-versions, as to our knowledge, it has never been done and might be interesting as we will see. We also intend to compare different combinations of archives. We considered as local archives the sorted list for p = 2, and the simple list with Move-to-Front heuristic (denoted List-MF ) for p ≥ 3.

As main archives, we compared: • only for p = 2: AVL-Archive, SAAVLA (self-adjusting version of AVL-Archive), the sorted list;

• for p ≥ 2: NDR * -Archive, SANDRA (self-adjusting version of NDR * -Archive), ND-Tree.

Results are shown in Tables 3.6 (p = 2), 3.7 (p = 3), 3.8 (p = 4), and 3.9 (p = 5). The first column of each table shows the instance size n, the second column indicates the average size of the final approximation set X all found, the third column indicates the proportion of dominated points φ dom , computed as the average number of dominated solutions presented to the archive divided by the number of (potentially) non-dominated points |X all |, the fourth column indicates the main archive used, next are displayed: the local archive used, the number of dominance comparisons, finally the execution time of PLS.

Overall, for p = 2, results are pretty homogeneous in terms of computational time and number of comparisons when a local archive is used. More precisely, better performance are obtained by using a local archive, except for SAAVLA which performs similarly with or without it.

Globally, AVL-Archive and SAAVLA performs slightly better than the sorted list (with local archive), the latter being around 10-15% slower. Given these results, we tested AVL-Archive as main and local archive, and found better results than using the sorted list as local archive.

Finally, NDR * -Archive and SANDRA obtain slightly better results than ND-Tree with local archive, and similar or better results than the sorted list with local archive. ND-tree without local archive is completely outperformed by the other archives.

For p ∈ {3, 4}, SANDRA without local archive is clearly the most effective combination, followed by SANDRA with local archive and NDR archive is approximately 50% slower than SANDRA. The number of comparisons is still at the advantage of SANDRA.

Conclusion

We proposed two new archives, AVL-Archive specialized in the bi-objective case, and NDR*-Archive for the general case. Both structures are self-balancing trees and have two versions: a general version suited for any multi-objective optimization task; and a self-adjusting version, especially designed if a presumption of temporal and spatial locality exists between the solutions presented to the archive. These archives have been experimentally tested and compared to other known state-of-the-art archives on a large benchmark of instances simulating the generation of points of a MO meta-heuristic, and inside a PLS for MOTSP up to 5 objectives. AVL-Archive outperforms all the other archives in the bi-objective case on the artificial benchmark tested and its self-adjusting version performs slightly better than the sorted list when used in PLS. NDR*-Archive performs better than competitors in the general case, particularly when p ≤ 4 and the number of dominated points is larger than the number of non-dominated points. The self-adjusting version of NDR*-Archive (SANDRA) is much more effective than competitors when used in PLS, especially for p = 3, 4.

We hope that these two archives and their self-adjusting versions could be useful for future meta-heuristics, particularly those using PLS, MO dynamic programming or search zones-based methods.

Concerning the perspectives of NDR*-Archive, one could keep sorted the children of an internal node (or the solutions of a leaf) using their Hilbert key like in [START_REF] Kamel | Hilbert r-tree: An improved r-tree using fractals[END_REF] (or any key provided by a space-filling curve, like the Peano curve). Like AVL-Archive which uses specific properties of the bi-objective case, it might be interesting to use the specific properties of objective spaces of fixed dimensions p = 3, 4 highlighted and practically applied in [START_REF] Fonseca | An improved dimensionsweep algorithm for the hypervolume indicator[END_REF] and [START_REF] Guerreiro | A fast dimensionsweep algorithm for the hypervolume indicator in four dimensions[END_REF]. More researches seem necessary to improve the efficiency of NDR*-Archive for p ≥ 5. For example, a new split or even a new procedure detecting efficiently if a candidate and the solutions in the archive are incomparable could be necessary to obtain better results.

One possible improvement of AVL-Archive is to use splay moves [START_REF] Sleator | Self-adjusting binary search trees[END_REF] to rearrange the tree so that the cache node is placed at the root of the tree. However, this modification could make the tree not balanced anymore.

Chapter 4

New optimization methods

This chapter proposes a number of new optimization methods and improvements of existing methods to tackle more efficiently MOCO problems. First are suggested some modifications of SO optimizers to improve their performance on MOCO problems.

Introduction

First, Section 4.1 suggests a number of improvements for SO optimizers and a new version of NMCS adapted to MOCO, Aggregation-based Nested Monte Carlo Search (A-NMCS). Second, Section 4.2 proposes Adaptive Maximally Dispersed set of Weights (A-MDW), a more adaptive and generalized version of MDW. Third, Section 4.3 introduces Partitioned Pareto Local Search (P-PLS), a method consisting in reducing the computational overhead of PLS. Then, Section 4.4 proposes 2-Phase Iterated Pareto Local Search with Decomposition (2PIPLS/D), a MO meta-heuristic based on the concepts of 2-Phase PLS, Decomposition methods and IPLS and combining A-MDW, P-PLS and the suggested improvements for SO optimizers. Section 4.5 presents a methodology to bound the size of the generated approximation set while guaranteeing a good distribution in the objective space of the points generated. Finally, we summarize the chapter.

Single-objective optimizers: improvements for MOCO

We saw that state-of-the-art MO meta-heuristics presented in Section 2.2 often optimize aggregation functions during their optimization process. We are particularly interested by weighted sum aggregations, as SO optimizers are directly able to solve the related problem. Indeed, efficient domain-specific SO optimizers which have already proved their reliability are generally available, even for hard problems. This section suggests some simple modifications on SO optimizers to greatly improve their ability for finding efficient solutions of MOCO problem instances. There are three main suggestions:

1. The first suggestion is to systematically start/guide the search of the SO optimizer from an already found solution, if this option is made available by the SO optimizer or even simple modifications in implementation can make it possible. In fact, this option is often either available or implementable: naturally in local search methods (see [START_REF] Paquete | A two-phase local search for the biobjective traveling salesman problem[END_REF] for example), but also in construction methods, like Monte Carlo Search methods as we will see later in this section. The aim is to start/guide the search process from a good quality solution instead of a randomly greedily generated one.

2. The second suggestion proposes the application of data perturbation on the cost function of the addressed weighted-sum problem. In fact, by optimizing weighted sum problems, the SO optimizer tends to focus its search toward supported solutions. Applying data perturbation on the cost function modifies the search direction of the SO optimizer, and potentially directs the search on any type of solutions (either supported or non-supported).

As previously indicated in Section 2.2.3, data perturbation has been introduced in MOCO optimization in [START_REF] Lust | Two-phase pareto local search for the biobjective traveling salesman problem[END_REF] for bi-objective TSP, but has not been reused after this paper, probably because it requires setting 3 parameters. We propose a simpler version of data perturbation (initially introduced in our work [START_REF] Cornu | Perturbed decomposition algorithm applied to the multi-objective traveling salesman problem[END_REF]) which needs a single parameter.

Given a weight λ ∈ Λ 0 and a small real δ > 0 controlling the maximum variation of the noise called data perturbation coefficient, data perturbation generates from the MO cost function c : E → R p the new SO aggregated and perturbed cost function c λ,δ : E → R such that: c λ,δ (e) = ν× p j=1 λ j c j (e) , ∀e ∈ E where ν ∼ U(1 -δ, 1 + δ) is a real number taken from a uniform distribution in the range [1 -δ, 1 + δ]. The higher δ, the larger the perturbation is. Once perturbation has been performed, the SO optimizer solves the data perturbed weighted sum problem λf δ (•) derived from c λ,δ . Naturally, λf δ (•) with δ = 0 corresponds to a classical (non-data perturbed) weighted sum problem: λf 0 (•) = λf (•), therefore λf δ (•) is a generalization of λf (•).

3. The last suggestion is, to our knowledge, a novel proposition (initially introduced in our work [START_REF] Cornu | Perturbed decomposition algorithm applied to the multi-objective traveling salesman problem[END_REF]) which consists in memorizing all relevant generated solutions in an archive during the whole run of a SO optimizer, instead of returning the best found solution for the addressed weighted-sum problem. The idea behind this suggestion is that, in general a SO optimizer finds several different solutions during its optimization process. While these solutions might be of lowest quality than the best found solution for the addressed weighted-sum problem, they could be efficient for the MOCO problem. This suggestion involves minor (and non-problem specific) modifications on the SO optimizer, by contrast it enables a much larger exploration of the search space of the MOCO problem. As an example, if the SO optimizer is an ILS, then the idea is to memorize in an archive all local optima obtained after each LS descent phase.

Aggregation-based Nested Monte Carlo Search

Let us introduce a new version of NMCS called Aggregation-based Nested Monte Carlo Search (A-NMCS) implementing the three suggestions presented above for SO optimizers. A-NMCS is described in pseudo-code by Algorithm 27 and works like NMCS with three differences (indicated with red color):

1. It optimizes a data perturbed weighted sum problem λf δ (•), δ ≥ 0.

2. The first call of A-NMCS can take as input parameter a sequence of actions seq best and its related solution x best . This allows the highest level of A-NMCS to follow, from the very beginning of the search, a sequence previously found by another run of A-NMCS, typically optimizing another but very similar data perturbed weighted sum problem, such that the starting sequence it provides is of good quality for both problems.

3. A global archive X all is maintained and any new solution generated by random simulations is presented to X all .

Adaptive Maximally Dispersed set of Weights

This section presents a new initialization procedure for any MO meta-heuristic, aiming at generating a starting approximation of the efficient set. It uses a concept extensively used in initialization phases of a number of meta-heuristics described in Section 2.2, in particular in the first phase of 2-phase PLS methods (2PPLS and TP+PLS) or during the initialization of methods based on decomposition (MOEA/D and MoMad): first a number of weights are generated, then the corresponding weighted sum problems are solved with a SO optimizer, and the generated solutions are memorized in an archive. While an efficient and problem-specific SO optimizer is mandatory to generate good quality points towards the non-dominated set, the diversification of the weights in the weight space is fundamental as it allows to generate points in the objective space well dispersed along the non-dominated set. We are interested in the second point.

The new method we introduce, called Adaptive Maximally Dispersed set of Weights (A-MDW), proposes to generalize MDW and make it more adaptive.

Motivations

MDW is largely used in the MO meta-heuristic research field as it is a simple and easily implementable method which generates well dispersed weights in the weight space. Unfortunately, MDW has two main drawbacks:

1. The parameter D, controlling the number of weights generated, has to be fixed. The value of this parameter is difficult to set because it depends on the instance characteristics of the addressed problem, like the number of objectives, the instance size and more complex features depending on the instance treated. In general, the user will set experimentally a D value for each tested instance of the addressed problem, which is a time-consuming offline task and mostly can not be the best setting.

2. A number of weights generated by MDW contain a 0 to some of their components, and thus do not evaluate the related objectives. This phenomenon is exacerbated as the number of objectives grows.

A-MDW circumvents the two issues of MDW depicted above by:

1. Replacing the original parameter D by a positive real α called the minimum acceptance rate threshold.

The idea is to iteratively generate equally dispersed weights like in MDW with an increasing parameter number D = 1, 2, ... controlling the number and the compactness of the generated weights, and stop once the solver does not generate enough new non-dominated solutions so that continuing to optimize weighted sum problems is no longer efficient.

• • • • • • (0, 0, 1) (0, 1, 0) (1, 0, 0) ( 1 2 , 1 2 , 0) (0, 1 2 , 1 2 ) ( 1 2 , 0, 1 2 ) Figure 4.1 -Edgewise Simplex subdivision of Λ 0 with b = 2 (p = 3).
2. Contrary to MDW which generates the weights only from Λ 0 , A-MDW can generate the weights from any simplex and thus generating weights with component values larger than or equal to ε ≥ 0.

Simplex subdivision

A-MDW uses as routine the Edgewise Simplex Subdivision of Gonçalves et al. [START_REF] Gonçalves | Algorithm 860: Simples -an extension of freudenthal's simplex subdivision[END_REF] to generate its weights. Given a (p-1)-dimensional simplex Λ, the method subdivides Λ into b p-1 (p-1)dimensional simplices with same volume and shape characteristics. The so-called base b ≥ 0 is the integer number by which an edge of the simplex is subdivided. Next we describe the procedure with any b, but we will use it only with b = 2. The method works as follows: given Λ, each edge of the simplex is cut in b parts; then Λ is subdivided into b p-1 smaller simplices, such that each pair of smaller simplices is either disjoint or meets along a common face [START_REF] Edelsbrunner | Edgewise subdivision of a simplex[END_REF]. The decomposition process is independent of the input simplex. Figure 4.1 describes the subdivision of Λ 0 with b = 2 and for p = 3, where 2 3-1 = 4 new simplices are generated.

Algorithm 28 shows how the method works to subdivide a simplex Λ with any base b in a p-dimensional space.

It returns the list LΛ of new simplices resulting of the subdivision of Λ. Although concise, the algorithm may seem pretty hard to understand at first sight, thus we propose an illustrated example in Figure 4.2 detailing the subdivision of a simplex with b = 2 in a tri-dimensional space (p = 3).

We assume that Λ = (λ 1 , ..., λ p ), where λ j ∈ R p ,j = 1, ..., p are vertices of Λ. The algorithm builds the b p-1 new simplices one at a time (loop iterating on s, line 3).

Let λs,1 , ..., λs,p ∈ R p be the future vertices of the s th simplex to build (line 4), s ∈ {1, ..., b p-1 }. The fundamental principle of the algorithm is that the vertices λs,j are built simultaneously (lines 5-14) such that the value assigned to each λs,j is a unique linear combination of b vertices of Λ, j = 1, ...p: s,i,j) b , j = 1, ...p where κ(s, i, j) ∈ {1, ...p} is a so-called color, i.e. an index identifying a vertex of Λ. The values taken by κ(s, i, j), i = 0, ..., b -1, j = 1, ...p follow a so-called color scheme. A color scheme is a b × p matrix K(s) = [κ(s, i, j)] such that each cell κ(s, i, j) ∈ {1, ...p} (i = 0, ..., b -1, j = 1, ...p) is a color, and built such that the colors are of increasing value and the columns are pairwise different in such a way that from column j -1 to column j, only one color is always increased by one.

λs,j = b-1 i=0 λ κ(
A color scheme K(s) is created row-by-row starting from κ(s, 0, 1) = 1. To find out if the next entry will be kept or increased by one, it is necessary to represent the integer number (s -1) in base b with p -1 digits:

x p-2 ...x 0 (line 5). The values of the digits x p-j , j = 2, ..., p determine which row i of column j -1 will be

+ + + /2= /2= /2= λ 1 λ 2 λ 3 λ 3 λ 3 λ 3 x 1 = 0 x 0 = 0 λ1,1 λ1,2 λ1,3 i = 0, 1 j = 2, 3
(a) 1 st new simplex: s = 1 ⇒ (s -1) 10 = 0 10 = 00 2 .

+ + + /2= /2= /2= λ 1 λ 2 λ 2 λ 2 λ 2 λ 3 x 1 = 0 x 0 = 1 λ2,1 λ2,2 λ2,3 i = 0, 1 j = 2, 3 (b) 2 nd new simplex: s = 2 ⇒ (s -1) 10 = 1 10 = 01 2 . + + + /2= /2= /2= λ 1 λ 1 λ 2 λ 2 λ 3 λ 3 x 1 = 1 x 0 = 0 λ3,1 λ3,2 λ3,3 i = 0, 1 j = 2, 3
(c) 3 nd new simplex: s = 3 ⇒ (s -1) 10 = 2 10 = 10 2 . // returns the simplex resulting from the subdivision of Λ: return LΛ increased by one to generate the column j (lines 10-11); and such that the following row starts with the last color in the preceding row, that is κ(s, i, 1) = κ(s, i -1, p):

+ + + /2= /2= /2= λ 1 λ 1 λ 1 λ 1 λ 2 λ 3 x 1 = 1 x 0 = 1 λ4,1 λ4,2 λ4,3 i = 0, 1 j = 2, 3 (d) 4 th new simplex: s = 4 ⇒ (s -1) 10 = 3 10 = 11 2 . • • • • • • λ 2 = λ2,2 λ 1 = λ4,1 λ 3 = λ1,3 λ1,1 = λ3,2 = λ4,3 λ2,1 = λ3,1 = λ4,2 λ1,2 = λ2,3 = λ3,3 (
K(s) =      κ(s, 0, 1) = 1 κ(s, 0, 2) . . . κ(s, 0, p) κ(s, 1, 1) = κ(s, 0, p) κ(s, 1, 2) . . . κ(s, 1, p) . . . . . . . . . . . . κ(s, b -1, 1) = κ(s, b -2, p) κ(s, b -1, 2) . . . κ(s, b -1, p) = p     
Finally, the j th column of K(s) defines the colors κ(s, i, j), i = 0, ..., b -1 used to build λs,j .

Design of A-MDW

The Edgewise Simplex Subdivision (with a base b = 2) is important for A-MDW as the vertices of the simplices correspond to weights if the input simplex is included in the weight space Λ 0 . In addition, one can subdivide the simplex Λ, then all the newly generated simplices, etc. and repeat the process several times. We call this process an iterative simplex subdivision. As the Edgewise Simplex Subdivision is independent of the input simplex, one can start an iterative simplex subdivision from any simplex. We are particularly interested in starting an iterative simplex subdivision from a so-called ε-restricted weight space:

Λ ε := {λ ∈ R p : λ j ≥ ε, j = 1, ..., p, p j=1 λ j = 1}, ε ≥ 0
By definition, Λ ε ⊆ Λ 0 for any ε ≥ 0, and Λ 0 = Λ with ε = 0. If ε > 0, then any weight λ generated by an iterative simplex subdivision starting from Λ ε has strictly positive values in each objective. Figure 4.3 illustrates an ε-restricted weight space in the weight space.

• • • • • • ε ε ε (0, 0, 1) (0, 1, 0) (1, 0, 0) Figure 4.3 -An ε-restricted weight space in p = 3 s.t. Λ ε = ((1 -2ε, ε, ε), (ε, 1 -2ε, ε), (ε, ε, 1 -2ε)), ε > 0.
Let us now introduce the generalized MDW formula:

           MDW(D, ε) := {λ = (λ 1 , ..., λ p ) : λ ∈ Λ ε , λ j = ε + d D • (1 -p • ε), d ∈ {0, ..., D}, j = 1, ..., p} such that min λ a ,λ b ∈Λε : λ a =λ b p j=1 λ a j -λ b j = 2 D • (1 -p • ε) 0 ≤ ε < 1 p (4.1)
We can see that if ε = 0, then MDW(D, ε) = MDW(D).

Proposition 4.2.1. Applying an iterative simplex subdivision starting from Λ ε with base b = 2 and I iterations, generates the same set of weights as MDW(2 I-1 , ε).

Proof. By construction, the set of weights provided by MDW(2 I-1 , ε) is equivalent to the set of weights generated by an Edgewise Simplex Subdivision with b = 2 I-1 starting from Λ ε [START_REF] Edelsbrunner | [END_REF]Grayson, 2000, Gonçalves et al., 2006], which is itself equivalent to an iterative simplex subdivision with b = 2 and I iterations.

Given a fixed ε ∈ [0; 1 p [ and a number of iterations, Proposition 4.2.1 indicates that the weights generated by an iterative simplex subdivision are equally dispersed and follow the same scheme of dispersion as the generalized MDW.

The successive generation of weights provided by an iterative simplex subdivision is illustrated by Figure 4.4. Next we present in detail how our method A-MDW works.

A-MDW consists in applying an iterative simplex subdivision initially started from an ε-restricted weight space, with base b = 2 and ε ∈ [0; 1 p [. At each iteration, the current simplices are subdivided, which generates a number of new weights. For each weight, the corresponding weighted sum problem is optimized and resulting solutions are stored in an archive. By construction, the new weights generated at a given iteration are built such that the minimum distance between all the weights generated so far decreases, which provides a set of weights more and more compact in the weight space. This leads to the generation in the objective space of an approximation of the non-dominated set of increasing quality through successive improvements. However, the improvement of quality induced by each iteration naturally tends to reduces when the number of iterations grows. Therefore, it is necessary to regularly use an indicator which evaluates the ability of the optimizer to improve the quality of the current approximation. As soon as the optimizer does not improve sufficiently the indicator value, then the procedure is stopped. Concerning the indicator to use, quality indicators, such as hypervolume or epsilon indicators, seem to be tools of choice for this task. Unfortunately, these indicators induce strong computational overhead and thus can not be used in practice.

• • • (a) 1 st iteration. • • • • • • (b) 2 nd iteration. • • • • • • • • • • • • • • • (c) 3 rd iteration.
-2 I-2 +p-1 p-1 , I ≥ 2.
Instead, we propose a simple yet efficient method which consists in collecting statistics about the total number of solutions generated by the optimizer and the total number of solutions accepted when presented to the archive. Once the percentage of accepted solutions reaches the minimum acceptance rate threshold α ∈ [0; 1] given as input parameter, then the optimizer is considered as inefficient, thus the process is stopped. We might be tempted to check it out between two iterations of the iterative simplex subdivision process only, unfortunately this option is not appropriate. Indeed, the total number of weights generated grows exponentially fast in function of both the number of iterations and the number of objectives, as it is equal to

2 I-1 +p-1 p-1
, where I is the number of iterations performed. Consequently, the number of new weights generated at each iteration, and thus the number of weighted sum problems to optimize, also increases exponentially. Figure 4.5 illustrates this behavior for p = 2, ..., 5 during 6 iterations of A-MDW.

Instead, it seems more appropriate to check if the percentage of accepted solutions reaches the threshold α each time a weighted sum problem has been optimized. By considering this option, the procedure can be stopped during any iteration while a number of new weighted sum problems will not be optimized. Therefore, at each iteration, it is necessary to sort the new weights so as to prioritize the optimization of weighted sum problems the most promising to provide a maximum of new solutions accepted in the archive (and thus currently non-dominated). We thus propose to order the weights given the efficiency of the simplex they belong to. The efficiency of a simplex corresponds to the sum of the number of accepted solutions provided by the optimization of the weighted sum problems corresponding to the vertices of the simplex. A-MDW is described in pseudo-code by Algorithm 29 and in diagram by Figure 4.6. It takes as input parameters a SO optimizer, a minimum acceptance rate threshold α ∈ [0; 1], and a small real ε ∈ [0; 1 p [ (typically ε ≤ 10 -3 ) for defining the input ε-restricted weight space from which the iterative simplex subdivision starts. The method returns the list Lλ all of all weights generated and an archive X all of all incomparable solutions generated. It maintains the list of current simplices LΛ (to be subdivided at the next iteration), initialized with the ε-restricted weight space Λ ε .

The main loop works as follows. First, any vertex of all simplices memorized in LΛ which has not already been considered is inserted in Lλ all and Lλ new , the set of new weights. For each new weight, the corresponding weighted sum problem is optimized with the SO optimizer. We assume that the optimizer may provide several different solutions in output and is able to take a solution in input. Then the statistics concerning the sum η accept of solutions accepted in the global archive X all and the total sum η total of solutions generated by the optimizer are updated. If the rate ηaccept η total has reached the minimum acceptance rate threshold α, then the method stops and returns the set of all weights Lλ all and the archive X all .

Once all new weights have been considered, then the simplices stored in LΛ are sorted given their efficiency. Finally, the simplices stored in LΛ are subdivided, then LΛ is reset with the new simplices. And the same process can continue.

Partitioned Pareto Local Search

This section presents a new iterative method based on PLS-VND called Partitioned Pareto Local Search (P-PLS). P-PLS consists in partitioning the archive to explore into a number of sub-archives, and building for each one a restricted neighborhood structure used by PLS-VND. The partitioning is made only once at initialization, and each sub-archive is made such that its solutions are neighbors in the objective space and its initial size is limited to a maximum number of solutions (defined by the user). Figure 4.7 illustrates the partitioning of an archive in a tri-objective space.

At each iteration of P-PLS, for each sub-archive, we extract the regularities found in the decision space between its solutions and build a model from these regularities. Typically, the model may consist in a statistical model or more simply a pool of rules on the elements composing the solutions. For example, it might be interesting to detect if the same element is present in all solutions of a sub-archive, or on the contrary, if some elements are completely absent from the sub-archive. The model is used to build a so-called neighborhood restriction structure. A neighborhood restriction structure is a function R : N -→ N which modifies a neighborhood structure N by reducing the search space of N in order to direct the search of new solutions in a restricted but promising part of the neighborhood of a solution, and thus speeding-up PLS-VND with a minimal reduction of quality of the generated approximation. For instance, if we keep the example of the component present in all solutions of a sub-archive, it may be judicious to forbid or at least to avoid new solutions without this component. PLS-VND is then conducted from the archive to explore (corresponding to the union of the sub-archives). During a PLS-VND run, the new solutions inherit the neighborhood restriction structure from their socalled parent solution. A solution x parent of another solution x is a solution from which a LS move has been performed and has led to the creation of x . Once PLS-VND is terminated, the archive to explore has been updated with new solutions, but not sub-archives, thus they are updated accordingly. Then the neighborhood restriction structure of each sub-archive XP is widened. A widening phase consists in rebuilding a neighborhood restriction structure by considering in addition to XP , the solutions of sub-archives close to XP in the objective space. A widening phase aims at enlarging the neighborhood restriction structure and therefore increasing the search space exploration. Sub-archives used to build a neighborhood restriction structure are called its sources. x ← arg min{λf (x) : x ∈ X all } X ←SO-Optimizer(λf (•), x) X all ←AddAll(X, X all ) // Update statistics:

η total ← η total + |X| N accept [λ] ← |{x ∈ X : x has been accepted in X all }| η accept ← η accept + N accept [λ]
// Is the acceptance rate has reached the min. threshold?

if η accept < α × η total then return (Lλ all , X all )
// Sort simplices:

sort LΛ in decreasing order s.t. each simplex Λ = (λ 1 , ..., λ p ) ∈ LΛ has the following sorting key: As it induces a computational overhead, we expect from widening of a neighborhood restriction structure that it leads to an improvement of the quality of the corresponding sub-archive during the next PLS-VND run. If no improvement of quality has been noted on a given sub-archive after a PLS-VND run, then this indicates that the extra informations gathered on solutions from new sources was useless for PLS-VND to find new solutions. Therefore, no more widening will be performed from its corresponding neighborhood restriction structure and thus no solutions belonging to this sub-archive will be explored anymore. Consequently, the widening of a given neighborhood restriction structure is performed only if its corresponding sub-archive has generated at least one new non-dominated solution during the previous PLS-VND run.

key(Λ) = p j=1 N accept [λ j ] LΛ next ← ∅ // Subdivide simplices: foreach Λ ∈ LΛ do LΛ next ← LΛ next ∪ SimplexSubdivision(Λ, 2) LΛ ← LΛ next
Once the widened neighborhood restriction structure has been built for each sub-archive, PLS-VND is conducted again from the archive to explore. During this new run, the (restricted) neighborhood of any new solution (i.e. newly generated since the previous run) is completely explored; while for old solutions, only newly accessible parts of the (restricted) neighborhood are explored.

This process of alternating PLS-VND with a widening phase at each iteration continues until a PLS-VND run does not generate any new non-dominated solution.

The notion of widening is related to the concept of progressive enlargement of neighborhood implemented in VND, and to the concept of progressive widening [Coulom, 2007] of MCTS, which consists in initially restricting the search of MCTS to the most promising actions only, and accept an increasing number of actions over time.

P-PLS is based on a fundamental assumption and a key observation:

1. P-PLS assumes the existence of global convexity. The concept of global convexity, introduced for MOCO in [START_REF] Borges | A study of global convexity for a multiple objective travelling salesman problem[END_REF], is not convexity in the strict sense, but may be used to denote the empirical observation that:

• efficient solutions of a MOCO problem instance are often concentrated in a small part of the decision space;

• solutions neighbors in the objective space tend to be also neighbors in the decision space.

In theory, global convexity and related notions such as connectedness of efficient solutions [START_REF] Ehrgott | Connectedness of efficient solutions in multiple criteria combinatorial optimization[END_REF] does not hold in general for a majority of classical MOCO problems [Ehrgott andKlamroth, 1997, Gorski et al., 2006]. By contrast, in practice, meta-heuristics extensively exploit this assumption with great success. For example, local search methods typically explore the search space close to current solutions, therefore local search is naturally favored by a concentration of efficient solutions; MO Estimation of Distribution Algorithms [START_REF] Pelikan | Multiobjective estimation of distribution algorithms[END_REF]] build a statistical model which detects regularities of solutions of a population and produce new comparable solutions, MO Genetic Algorithms like Decomposition based methods [START_REF] Zhang | MOEA/D: A multiobjective evolutionary algorithm based on decomposition[END_REF] apply crossover on solutions close in the objective space to produce new similar solutions in the decision space, etc. Assuming the existence of global convexity tends to legitimate the general idea of P-PLS. Indeed, as the solutions from a sub-archive are neighbors in the objective space, they are globally similar in the decision space by global convexity assumption, therefore the regularities extracted from this population might potentially be strong and thus useful for the efficiency of the search space reduction.

2. We observe in the literature that PLS is generally used with small neighborhood structures. As examples:

• state-of-the-art methods for MOTSP use 2-opt [START_REF] Lust | Two-phase pareto local search for the biobjective traveling salesman problem[END_REF], Ke et al., 2014, Cornu et al., 2017];

• for MO Multidimensional KP, a popular neighborhood move consists in removing a certain percentage of objects from the knapsack, then replace them by other objects. The percentage corresponds to the size of the neighborhood. The current best method for this problem uses a small (as admitted by the authors) neighborhood size of 2% [START_REF] Ke | A simple yet efficient multiobjective combinatorial optimization method using decompostion and pareto local search[END_REF];

• concerning MOQAP (see [Drugan andThierens, 2010, Dubois-Lacoste et al., 2015] as examples), the neighborhood move generally used consists in swapping the position of two facilities;

• similar observations can be made for the MO set covering problem [START_REF] Lust | Variable and large neighborhood search to solve the multiobjective set covering problem[END_REF], and the MO Flow-Shop Scheduling Problem [START_REF] Dubois-Lacoste | Combining two search paradigms for multi-objective optimization: Two-phase and pareto local search[END_REF].

As pointed out in [START_REF] Ke | A simple yet efficient multiobjective combinatorial optimization method using decompostion and pareto local search[END_REF] and [START_REF] Lust | Variable and large neighborhood search to solve the multiobjective set covering problem[END_REF] among other studies, large neighborhood size induces strong computational overheads, thus only small neighborhood structures are employed. By contrast, it is well known that increasing the size of a neighborhood drastically increases the quality of results.

In P-PLS the computational resources saved by the search space reduction can be reallocated to explore neighborhood of larger size. P-PLS is described in diagram by Figure 4.9 and detailed in pseudo-code by Algorithm 30. P-PLS takes the same input parameters as PLS-VND, with a small modification: we assume that the starting set X (to explore) is an archive. As usual, X all denotes the global archive. The other input parameters correspond to the set of neighborhood structures (N 1 , ..., N k ) used by PLS-VND and two boolean defining the different possible search strategies of PLS-VND: the first dominating exploration strategy already mentioned (parameter first-dominating), and the possibility of avoiding the exploration of the neighborhood of dominated solutions (parameter explore-dominated) which is a new feature (initially introduced in our work [START_REF] Cornu | Perturbed decomposition algorithm applied to the multi-objective traveling salesman problem[END_REF]) we propose for PLS-VND and which will be discussed later. A last input parameter is the maximum authorized initial size σ of a sub-archive. P-PLS returns the global archive X all .

P-PLS manages a partition LP implemented as a set of parts. A part P ∈ LP is a tuple composed of:

Initialize partition:

• partition X into local archives • build a number of parts P s.t.:

-X(P ) is a sub-archive -LS(P ) ← {P } is a set of sources -R(P ) is a neighborhood restriction structure built from LS(P ) & insert P into the set of parts LP .

• run PLS-VND from archive X with restricted neighborhood structs.

• let X new be the set of all newly generated solutions Is X new = ∅? yes Update partition:

• update X(P ), ∀P ∈ LP • for each active part P ∈ LP :

enlarge LS(P ) with nearby parts widen R(P ) accordingly no Figure 4.9 -The P-PLS procedure.

Algorithme 30 : P-PLS Input : set of neighborhood structures (N 1 , ..., N k ), boolean first-dominating, boolean explore-dominated, maximum initial size of part σ, starting archive (to explore) X, global archive X all Output : X all LP ←InitializePartition(σ, 1, X) repeat X all ←PLS-VND((N 1 , ..., N k ), first-dominating, explore-dominated, X, X all ) X new ← {x ∈ X : x has been generated at current iteration}

LP ← UpdatePartition(LP , X new ) until X new = ∅; return X all
• a sub-archive X(P ) which is a subset of X;

• a set of parts called sources LS(P ) ⊂ LP ; initially, the only source is P itself (LS(P ) = {P } at first call of PLS-VND);

• a neighborhood restriction structure R(P ) built from the solutions of the sub-archives of the sources LS(P ).

such that X = P ∈LP X(P ). Each solution x ∈ X belongs to a unique sub-archive, and to any x is attached an attribute P (x) indicating the part to which x is associated. This will allow to apply to the neighborhood of x the relevant neighborhood restriction structure during PLS-VND.

P-PLS starts by partitioning the archive to explore X and creates the parts of the partition by calling the InitializePartition procedure (Algorithm 31). At each iteration of the main loop of P-PLS (Algorithm 30), first PLS-VND (Algorithm 32) is conducted from X, then the UpdatePartition procedure (Algorithm 34) is called: it updates sub-archives with the set of new solutions X new found at this iteration and widens neighborhood restriction structures. P-PLS stops once X new is empty and returns the global archive X all .

Algorithme 31 : InitializePartition Input : maximum initial size of part σ, index of split objective j, archive X Output :

set of partition LP if |X| > σ then sort X given the split objective j so that X = {x 1 , ..., x |X| } X 1 ← {x 1 , ..., x |X|/2 } X 2 ← {x |X|/2 +1 , ..., x |X| } LP 1 ←InitializePartition( σ, (j mod p) + 1, X 1 )
LP 2 ←InitializePartition( σ, (j mod p) + 1, X 2 )

return LP 1 LP 2 else // |X| ≤ σ ⇒ Creation of a new part: P ←new Part X(P ) ← X LS(P ) ← {P } R(P ) ← BuildRestriction(X) foreach x ∈ X(P ) do P (x) ← P return P
The InitializePartition procedure (Algorithm 31) is a recursive method which shares the same partitioning process as a k-d tree [Bentley, 1975]. Each call consists in splitting the input archive in two subsets of equal size by considering the values of solutions on a single objective. The method cycles over the split objectives. As soon as the size of the input archive is lower than or equal to the maximum authorized size of a part σ (passed in input), then a new part P is created: the sub-archive X(P ) corresponds to the input archive, the set of sources LS(P ) is initialized with P itself, the neighborhood restriction structure R(P ) is then built from X(P ). Finally, each solution of X(P ) is associated to P . When the procedure terminates, the whole set of parts LP is returned.

Concerning PLS-VND, we propose a novel option to the original method presented in Section 2.2.3.5. In addition to the first dominating exploration strategy, we add the possibility not to explore the neighborhood 33). Checking the presence of x in X all is made in constant time by associating to each solution a flag turned off once another solution dominates it in the global archive.

2. The inclusion of P-PLS features: instead of exploring the whole neighborhood N j (x) of a solution x, we first apply to N j (x) the neighborhood restriction structure R(P (x)) of the part associated to x (line 4 of Algorithm 33). Once a new solution x has been accepted in X all , then we assign as part of x the part of x (line 8 of Algorithm 33).

Algorithme 34 : UpdatePartition

Input : set of parts LP , archive of new solutions X new Output : LP // Remove dominated solutions from archives of parts: foreach P ∈ LP do First, sub-archives are updated with new solutions, thus dominated solutions from sub-archives are removed, and new solutions from X new are added into relevant sub-archives (lines 1-6). A set of parts LP a collects all active parts. A part is said to be active if at least one new solution has been inserted in its sub-archive.

X(P ) ← X(P ) \ {x ∈ X(P ) : ∃x ∈ X new , f (x ) ≤ f (x)} //
Then, the set of sources of any active part is enlarged with nearby parts (lines 7-11). For a given active part, the idea is to add as sources the parts all around the current set of sources of the part. We define the distance between two parts as the Euclidean distance between the center of their respective sub-archives, where the center of a set of points is the average point of its local ideal and its local nadir. For each active part P , we add as new sources of P the 2 p-1 closest parts from P .

Finally, the restriction structure of each active part is widened according to its new set of sources (lines 12-14).

Note that the set of active parts computed at each iteration of P-PLS by the UpdatePartition procedure is of non-increasing size. Indeed, once a part does not generate any solution at a given iteration, its neighborhood restriction structure will not be widen, and thus none of its solutions will generate any new solution at the next PLS-VND iterations.

A related comment concerns PLS-VND. As mentioned, a new solution generated by PLS-VND inherits its part from its parent. Naturally, this algorithmic choice can lead to the situation where a new solution is actually closer from another part. This situation appears in Figure 4.8, for some solutions at southeast of the part of interest. In practice, this occurs marginally. Moreover, a first algorithmic choice had been instead to associate to any new solution the part from which the solution is the closer from the center of its sub-archive. This enabled to obtain more compact parts. Unfortunately, this also reactivated non-active parts through the UpdatePartition procedure and thus increased considerably the computational time of P-PLS for no great improvement of quality.

2-Phase Iterated Pareto Local Search with Decomposition

The new meta-heuristic we propose, 2-Phase Iterated Pareto Local Search with Decomposition (2PIPLS/D), combines the concepts of three successful methodologies: 2-Phase PLS (Section 2.2.3.6), Decomposition methods (Section 2.2.2) and IPLS (Section 2.2.3.7); and also implements the new features previously introduced in this section: the suggestions of improvement for SO optimizers, A-MDW and P-PLS. 2PIPLS/D is a 2-phase method.

The first phase consists in generating an initial high quality approximation of the efficient set. First, A-MDW is utilized, then P-PLS is conducted from the initial approximation set.

The second phase aims at iteratively refining the approximation set. As a Decomposition method, 2PI-PLS/D keeps in memory all the weights generated in the first phase, and maintains for each weight λ ∈ Λ 0 a so-called incumbent x ∈ X, which is the best solution for the weighted-sum problem λf (•) found so far. A so-called sub-problem (λ, x) is a pair composed of a weight λ ∈ Λ 0 and the associated incumbent x ∈ X. As 2PIPLS/D is an IPLS, the second phase alternates PLS-VND run with a global perturbation step generating new starting solutions for next PLS-VND run.

The global perturbation step consists in first choosing a number of sub-problems. For each selected subproblem, the incumbent is perturbed and the related weighted-sum problem is data perturbed, then optimized. As the set of incumbents corresponds to an approximation of the supported efficient set, it is generally much smaller than the best-so-far approximation set and is composed of solutions present all along the best-so-far approximation set. Therefore, the perturbation mechanism allows us to generate new solutions dispersed all along the best-so-far approximation set.

Any run of PLS-VND (both in first and second phases) uses the neighborhood restriction structures built by P-PLS at first phase. The SO optimizer used by A-MDW and during the global perturbation step naturally implements the suggestions we have proposed: it memorizes all generated (or useful) solutions and it starts/guides its optimization from a starting solution.

In Decomposition algorithms like MOEA/D or MoMad, each sub-problem provides a unique search direction.

We claim that focusing optimization on the same directions during the entire duration of the run may neglect other attractive areas of the search space. This is the reason why in 2PIPLS/D, the weighted-sum problems optimized during second phase are data perturbed in order to produce a stochastic change to the sub-problem search direction (as initially done in our work [START_REF] Cornu | Perturbed decomposition algorithm applied to the multi-objective traveling salesman problem[END_REF]). During the first phase, A-MDW is run from a restricted weight space Λ ε with ε ∈ [0; 1 p [ (typically ε ≤ 10 -3 ) and generates a set of equally dispersed weights Lλ all and a global archive X all . Then, P-PLS is conducted from X all , generating a set of neighborhood restriction structures and enriching the global archive X all . Finally, the set of sub-problems Π is initialized (Algorithm 36) such that each sub-problem (λ, x) ∈ Π is composed of a weight λ ∈ Lλ all to which is associated an incumbent x ∈ X all .

Algorithme 37 : SelectSubProblems Input : set of sub-problems Π Output :

subset of selected sub-problems Π select X se ← {x ∈ X : (•, x) ∈ Π} Π select ← ∅ foreach x ∈ X se do λ ← select uniform {λ ∈ Λ 0 : (λ, x) ∈ Π} Π select ← Π select + (λ, x) return Π select
Let us now describe the second phase. At each iteration:

1. Firstly, a global perturbation step is performed:

• A subset of the sub-problems Π select is selected from Π (Algorithm 37). A-MDW may generate a large number of weights, so that a single solution may be the incumbent of several sub-problems. The aim is to optimize a single data perturbed weighted sum problem for each unique incumbent. Thus, for each unique incumbent x ∈ X, a weight λ ∈ Λ 0 is selected uniformly at random from the set of sub-problems Π such that (λ, x) is a sub-problem.

• For each selected sub-problem (λ, x) ∈ Π select , the incumbent is perturbed providing a new solution x ∈ X, then the weighted-sum problem is data perturbed with the coefficient δ ≥ 0 and the SO optimizer is used to optimize λf δ (•) starting from x . The archive X perturb memorizes all incomparable solutions generated by the SO optimizer at current iteration.

2. Secondly, PLS-VND (Algorithm 32 using neighborhood restriction structures) is performed from X perturb .

In addition to the first dominating exploration strategy (first-dominating parameter) and the option consisting in exploring or not the neighborhood of dominated solutions (explore-dominated parameter), 2PIPLS/D gives the possibility to use PLS-VND in independent mod (independent-pls parameter). In independent mod, PLS-VND is run from X perturb from scratch in such a way that X all is completely ignored and any solution from X all can thus be rediscovered during the process. To our knowledge, this mod is used by all known proposed implementations of IPLS [START_REF] Drugan | Path-guided mutation for stochastic pareto local search algorithms[END_REF], Drugan and Thierens, 2012,Inja et al., 2014]. In dependent mod, X all is considered, thus any solution from X perturb weakly dominated by a solution from X all is removed, then PLS-VND is conducted from X perturb with X all as global archive. To our knowledge, this mod is only used by MoMad [START_REF] Ke | A simple yet efficient multiobjective combinatorial optimization method using decompostion and pareto local search[END_REF]. At the expense of a much higher computational resources need, PLS-VND in independent mod has a superior exploration power than PLS-VND in dependent mod.

After PLS-VND, the incumbents of sub-problems are updated with new solutions from X all found at current iteration (Algorithm 38).

2PIPLS/D stops as soon as either no new solution has been accepted in the global archive X all at the current iteration, or the stopping criterion given by the user is met.

Preservation of a good distribution of points in the objective space

In addition to the difficulty for finding a good quality approximation of the non-dominated set, metaheuristics have to provide a set of points well-distributed along the non-dominated set. An issue arises when the addressed problem is intractable, making impossible the memorization of all the non-dominated points for some instances of the problem.

In order to maintain a set of well-distributed points in the objective space and bound the size of this set during the optimization process, Laumanns et al. [START_REF] Laumanns | Combining convergence and diversity in evolutionary multiobjective optimization[END_REF] have introduced the concept of -archive. They propose to place a hyper-grid that discretizes the objective space into regions called boxes.

A box can contain at most one point. An -archive takes as parameter a tolerance > 0, which controls the dispersion of the points and implicitly determines the maximal size of the approximation. The larger , the larger the dispersion of the points and the smaller the size of the approximation will be. Guarantees on the good distribution of points in the -archive and on the bound on its size are given in [START_REF] Laumanns | Combining convergence and diversity in evolutionary multiobjective optimization[END_REF].

We propose a modified version of the original -archive. The aim of the proposed -archive is not to maintain an approximation of the non-dominated set, but rather to bound the size of the archive while guaranteeing a good distribution of the points of the approximation in the objective space.

Let > 0 be a fixed tolerance parameter. Let z = (z 1 , ..., z p ) ∈ Z be a point and box(z) = (box 1 (z), ..., box p (z)) the vector of the box z belongs to, such that box j (z) = log z j log(1+ ) is the coordinate of the box on the j-th objective, for j = 1, ..., p.

Let z ∈ Z be a point. The local ideal point z * ∈ Z related to z is the point sharing the same box as z and dominating all the points in this box, i.e. z * is such that for any z ∈

Z : if box(z ) = box(z), then z * z . Let z, z * ∈ Z be two points such that z * is the local ideal point of z. Let D(z, z * ) := lex    max j=1,...,p {z j -z * j }; p j=1 (z j -z * j )   
be the distance between z and z * .

When an -archive is used instead of a regular unbounded archive, the following procedure replaces the original Add procedure (Algorithm 2). When a solution x ∈ X s.t. z = f (x) ∈ Y enters the -archive X:

• if there exists x ∈ X st. z = f (x ) : box(z ) < box(z), then x is not added to X; • otherwise, if there exists x ∈ X st. z = f (x ) : box(z) < box(z ), then x is added to X and x is removed from X; f 1 f 2 • • • • (a) Global perturbation step (1/2):
Application of perturbation moves on incumbents of selected sub-pbs.

f 1 f 2 • • • • • • • • • • • • (b) Global perturbation step (2/
2): Optimization of data perturbed weighted sum problems of selected sub-pbs starting from perturbed incumbents. ( 1 + )

f 1 f 2 • • • • • • • • (
2 ( 1 + ) 3 ( 1 + ) 4 1 + (1 + ) 2 (1 + ) 3 (1 + ) 4 • z * • z • z f 1 f 2 Figure 4
.12 -Hyper-grid of an -archive represented in the objective space. z, z ∈ Y share the same box.

• otherwise, if there exists x ∈ X st. z = f (x ) : box(z) = box(z ), then:

-If D(z, z * ) < D(z , z * ) where z * ∈ Z is the local ideal point related to z, then x is added to X and x is removed from X -Otherwise, x is not added to X • otherwise, z is added to X.

Conclusion

We proposed in this chapter a number of improvements of existing methods and new optimization methods to tackle more efficiently MOCO problems.

First we suggested three modifications of SO solvers to improve their ability to find efficient solutions in MOCO problems: systematically starting/guiding the search from an already found solution, memorizing the solutions generated during the optimization process and enable the data perturbation of a weighted sum problem. Based on these specifications, we proposed a new version of NMCS, called Aggregation-based Nested Monte Carlo Search (A-NMCS) better suited for MOCO than vanilla NMCS.

Second, we presented a new method generalizing the concept of MDW called Adaptive MDW (A-MDW) and making it more adaptive such that the method continues generating weights until the SO solver optimizing the related weighted sum problems is no longer efficient. Third, we introduced Partitioned Pareto Local Search (P-PLS), which aims at speeding-up PLS-VND through the partitioning of the set of solutions to explore, and a smart restriction of the PLS-VND neighborhood structure based on the presumption of global convexity on the addressed problem.

Then, we proposed a new MO meta-heuristic called 2-Phase Iterated Pareto Local Search with Decomposition (2PIPLS/D) based on three successful methodologies: 2-Phase meta-heuristics, Decomposition methods and IPLS, and combining A-MDW, P-PLS, as well as the suggested modifications for SO solvers.

Finally, a new system based on the -archive concept is presented, allowing to bound the size of an archive while guaranteeing a good distribution of the points in the objective space.

Chapter 5

Application of 2PIPLS/D to MOTSP

In this chapter, we apply 2PIPLS/D to MOTSP. We first detail the implementation of the different algorithmic components of 2PIPLS/D, then propose an empirical evidence of global convexity on MOTSP in order to legitimate the use of the P-PLS partitioning. After a sensitivity analysis of 2PIPLS/D on its parameters, we propose a final parameter setting. Finally, we compare the method with the best known algorithms on a large benchmark of bi-objective and tri-objective instances.

Introduction

This chapter proposes the application of 2-Phase Iterated Pareto Local Search with Decomposition (2PI-PLS/D) to MOTSP. Section 5.1 first presents the benchmarks of bi-objective and tri-objective instances used for the experiments, then Section 5.2 describes how 2PIPLS/D has been implemented for MOTSP, in particular it details the SO optimizer(s) and the perturbation move selected, the PLS-VND neighborhood structure utilized and the neighborhood restriction structure used in P-PLS. Then Section 5.3 proposes an empirical evidence of existence of global convexity on MOTSP, in order to justify the use of P-PLS (as it is suggested in Section 4.3). After a sensitivity analysis of 2PIPLS/D on its parameters, a good final parameter setting is proposed in Section 5.4. A comparison of 2PIPLS/D with state-of-the-art methods on MOTSP is made in Section 5.5. Finally, we summarize the chapter and propose a number of perspectives concerning MOTSP.

MOTSP benchmarks and experimental design

Types of instances

The MOTSP instances used in our experiments either come directly from the literature or have been generated with exactly the same process as in the literature. They are of different types:

• Euclidean instances: an instance is composed of p single-objective Euclidean instances. For each objective, the costs between the edges correspond to the Euclidean distance between two cities in a plane.

Most of Euclidean instances comes from the TSPLIB1 library [Reinelt, 1991] or have been generated with the same process as in TSPLIB. More precisely, on each objective, the coordinates of each city are integers that are uniformly and independently generated in the range [0,3163]. These instances are denoted as Krolak/Felts/Nelson (abbreviated as "kro") instances. Other instances have been produced by the DIMACS instance generator2 .

• Clustered instances: an instance is composed of p single-objective clustered instances. For each objective, the cities are randomly clustered in a plane, and the costs between the edges correspond to the Euclidean distances. All clustered instances have been produced with the DIMACS instance generator, such that any instance of size strictly lower than 100 is composed of 12 clusters, and any instance of size greater than or equal to 100 is composed of 25 clusters.

• Random instances: the costs between the edges are randomly generated from a uniform distribution. All random instances have been produced with the DIMACS instance generator, such that each component of the cost vector assigned to an edge (between two cities) is chosen as an integer value taken from a uniform distribution in the range [0,4473]. This range was chosen in order to have a range similar to the one of the kro instances (note that √ 2 × 3163 2 + 0.5 = 4473).

• Mixed instances (only for the bi-objective case): the first cost corresponds to the Euclidean distance between two cities in a plane and the second cost is randomly generated from a uniform distribution.

Benchmarks of MOTSP instances

Two different benchmarks are utilized. The learning benchmark is first used to make an empirical evidence of the global convexity on MOTSP (Section 5.3), then to propose a good parameter setting for 2PIPLS/D (Section 5.4). The test benchmark is employed for the comparison of 2PIPLS/D with its competitors (Section 5.5).

Learning benchmark

The learning benchmark is composed of 80 bi-objective and tri-objective instances of different sizes and types:

• 10 bi-objective Euclidean instances of size 100, and 10 of size 500;

• 10 bi-objective random instances of size 100, and 10 of size 500;

• 10 tri-objective Euclidean instances of size 100, and 10 of size 500;

• 10 tri-objective random instances of size 100, and 10 of size 500.

Euclidean instances have been generated with the same process as kro instances mentioned above, and random instances have been produced with the DIMACS instance generator.

Test benchmark

The benchmark used for the comparison between 2PIPLS/D and its competitors on MOTSP is described in Table 5.1 and is composed of 55 instances: 30 bi-objective instances with a size ranging from 100 to 1000, and 25 tri-objective instances with a size ranging from 50 to 500 such that:

• 40 instances come from the literature [Jaszkiewicz, 2002, Paquete and Stützle, 2003, Paquete et al., 2004, Angel et al., 2004, Lust and Teghem, 2010, Lust and Jaszkiewicz, 2010] (30 bi-objective, 10 triobjective). The Euclidean kro instances come either from the TSPLIB library or have been generated by Lust and Teghem 3 [Lust and Jaszkiewicz, 2010]. The rest of instances has been produced with the DIMACS instance generator.

• 15 additional tri-objective instances we have generated with the same process as kro instances or with the DIMACS instance generator.

Experimental design

For all bi-objective instances and small-size (n < 100) tri-objective instances, the sets of points of all tested methods (i.e. 2PIPLS/D and its competitors) are managed as regular unbounded archives (i.e. with a tolerance for dominance relations = 0%).

For tri-objective instances with n ≥ 100, the size of the non-dominated sets is very large, in consequence the archives of all tested methods are managed as -archives with the technique preserving a good distribution of the points described in Section 4.5, with a tolerance = 1%. Note that the computational cost of the log function is negligible because the required log values are precomputed and stored in a look-up table before the beginning of each instance optimization.

All experiments were performed on a 3.4 GHz computer with 16Gb of volatile memory (RAM) on a Linux OS.

Implementation of 2PIPLS/D to address MOTSP

2PIPLS/D is written in C/C++. Different algorithmic components of 2PIPLS/D have to be chosen and implemented for the addressed problem: the SO optimizer, the perturbation move, the neighborhood structure used by PLS-VND and the neighborhood restriction structure utilized in P-PLS.

SO optimizer

Concerning the SO optimizers, we compare two different methods: the local search-based method Chained Lin-Kernighan [START_REF] Applegate | Chained lin-kernighan for large traveling salesman problems[END_REF]] (C-LK), and the Monte Carlo Search-based method NMCS (Section 2.2.5.3) and A-NMCS (Section 4.1.1), its version especially designed for MOCO. C-LK is the solver used in the last three best methods on bi-objective TSP (2PPLS [START_REF] Lust | Two-phase pareto local search for the biobjective traveling salesman problem[END_REF], MoMad [START_REF] Ke | A simple yet efficient multiobjective combinatorial optimization method using decompostion and pareto local search[END_REF] and PDA [START_REF] Cornu | Perturbed decomposition algorithm applied to the multi-objective traveling salesman problem[END_REF]). As in the literature, we use the C-LK implementation of the Concorde package4 . As suggested in Section 4.1, we have implemented a modified version of C-LK so that it memorizes all incomparable locally minimum solutions generated. We call this version improved C-LK, while the nonmodified version is called vanilla C-LK.

On the other hand, NMCS has never been adapted to this problem. We chose NMCS because it has been successfully applied to a number of difficult SO problems (as mentioned in Section 2.2.5.3). Consequently, it appears to us interesting to analyze the performance of 2PIPLS/D when using such a promising method which is NMCS (and A-NMCS) with a problem-dependent and efficient ILS method such as C-LK. The idea is also to gauge the dependence of 2PIPLS/D on the SO optimizer used.

Note that we have also tested two other SO optimizers: the Helsgaun implementation of Lin-Kernighan, called LKH [Helsgaun, 2000]; and the Genetic Algorithm using Edge Assembly Crossover (GA-EAX) [START_REF] Nagata | A powerful genetic algorithm using edge assembly crossover for the traveling salesman problem[END_REF]. Internal tests have shown that C-LK and LKH provide globally similar performance, as already observed in [START_REF] Lust | Two-phase pareto local search for the biobjective traveling salesman problem[END_REF] while GA-EAX provided surprisingly poor results. For these reasons, we do not consider these two solvers in the rest of this document.

Implementation of (A-)NMCS for MOTSP

In our implementation of (A-)NMCS, the construction of a sequence consists in building a tour by iteratively adding an edge to a path. More precisely, a starting city is first selected at initialization of (A-)NMCS, such that all generated sequences will share this city as starting city. By ease of simplicity, we select as starting city the first city of the addressed instance. A partial sequence represents a path, and technically it corresponds to a pair composed of:

• a current city, initialized with the starting city;

• and an ordered list of actions, where an action consists first in the insertion of a valid edge present in the candidate edge list of the current city, then the change of current city to the newly introduced city.

A valid edge consists in an edge whose insertion does not forbid the partial sequence to finally be a valid tour.

The concept of candidate edge list used in (A-)NMCS is exactly the same as in local search, so as it consists in a fixed-size set of elite edges computed for each city. Let c λ,δ (e) (to be minimized) be the aggregated and perturbed cost function of an edge e ∈ E, where λ ∈ Λ 0 is a weight and δ ≥ 0 is a data perturbation coefficient (see Section 4.1) and such that λf δ (•) is the fitness minimized by (A-)NMCS. Let cel(χ) be the candidate edge list associated with the city χ, such that cel(χ) contains the s best edges incident to χ given c λ,δ (e). Let the normalized cost c λ,δ (e, χ) ∈ [0, 1] of an edge e ∈ E from χ be defined as:

c λ,δ (e, χ) = c λ,δ (e) -c λ,δ min (χ) c λ,δ max (χ) -c λ,δ min (χ)
where e is incident to a city χ, and c λ,δ min (χ) (resp. c λ,δ max (χ)) is the minimum (resp. maximum) cost among all edges incident to χ, defined as:

c λ,δ min (χ) = min{c λ,δ (e ) : e ∈ cel(χ)} c λ,δ max (χ) = max{c λ,δ (e ) : e ∈ cel(χ)}
During a random simulation (level of recursion equal to 0), an edge e ∈ cel(χ) incident to the current city χ of a partial sequence seq is randomly selected with the following Boltzmann distribution formula: (e,χ) e ∈cel(χ)\χ(seq) e -β× c λ,δ (e ,χ) where χ(seq) is the set of cities present in the partial sequence seq (i.e. already selected in previous actions and thus invalid for selection) and β ≥ 0 is a parameter to be fixed. This formula encourages the selection of low-cost edges in a random way, such that the higher β is, the higher the probability of the smallest-cost edges to be selected. If β = 0, then the selection consists in a uniform random selection. The normalization of the cost of the edges allows for setting the same β value for all cities.

P(e | seq) = e -β× c λ,δ
At a given level of recursion greater than or equal to 1, (A-)NMCS tries all available actions among these allowed by the candidate edge list of the current city.

At a given step of selection of an action (at any level of recursion), if no edge from the candidate edge list of the current city is valid, then the edge with the smallest cost is selected. This implementation of (A-)NMCS has 3 parameters to be fixed: the usual level of recursion level, the size of the candidate edge list s and the Boltzmann parameter β. We have tested different configurations of values on the learning benchmark presented above, and we obtain best results with the following configuration: level = 1, s = 10, β = 20. Note that we have chosen a small level of recursion because higher levels of (A-)NMCS provided far too large execution times compared to C-LK runs. Indeed, recent versions of Lin Kernighan have a complexity of O(n κ ), where κ 2 [Helsgaun, 2000], while (A-)NMCS has a complexity of O(n 1+level ).

Perturbation move

The perturbation move used at perturbation step (second phase of 2PIPLS/D) selected is the double bridge move (see Section 2.3.1) as it is simple, efficient and the most used in the literature. We use the implementation of Paquete5 .

Neighborhood structures of PLS-VND

The neighborhood structures used by PLS-VND are usual k-exchange neighborhoods. We consider as maximum neighborhood structure size k ∈ {2, 3} for PLS-VND. Obviously, PLS-VND with k = 2 corresponds to PLS.

Implementation of the neighborhood restriction structure of P-PLS

The neighborhood restriction structure employed in each part of P-PLS uses the combination of two preexisting techniques in a dynamic way: the candidate edge list (presented in Section 2.3.1) and the locked edges (Section 2.3.2). For a given part:

• the candidate edge lists contain only the edges present in at least one solution in the archives of the sources of this part (they can be considered as the union of edges of solutions of the sources).

• the locked edges is the set of edges present in all solutions in the archives of the sources of this part (they can be considered as the intersection of edges of solutions of the sources).

As indicated in Section 4.3, the neighborhood restriction function of an active part is built after the enlargement of the set of sources (Algorithm 34). The construction of the neighborhood restriction structure consists in building the candidate edge lists and identifying the locked edges. During PLS-VND, a move from a given solution will consist in exchanging a number of non-locked edges of the solution only for edges contained in a candidate edge list (with the exception of the close-up edge).

When P-PLS is running, the neighborhood restriction function of each active part is re-built at each iteration.

As the size of the archives of the parts tends to increase when the number of iterations grows, the size of the candidate edge lists of an active part also tends to increase, while the set of locked edges of an active part tends to decrease. Note that both techniques have already been employed: the candidate edge list used in 2PPLS is used in a static way, as it consists in the edges present in at least one solution of the initial set found in the first phase, then used in PLS during the second phase. In MoMad, the candidate edge list is used in a more dynamic way as it consists in the edges present in at least one solution of the global archive, in such a way that the candidate edge list tends to increase at each new call of PLS. The locked edges technique has been introduced in MOCO in [Jaszkiewicz, 1999] and used by [START_REF] Jaszkiewicz | Efficient adaptation of the pareto memetic algorithm to the multiple objective travelling salesperson problem[END_REF], such that locked edges are used in a static way in a path relinking procedure. The originality of our neighborhood restriction structure lies in the combination of these two techniques, the utilization of locked edges in a dynamic way, and obviously the embedding of such a structure in the partitioning system of P-PLS.

Technically, a matrix of all edges is memorized in each part, therefore the partitioning of P-PLS is volatile memory consuming, as the RAM needed is O(

|Xall| σ × n(n-1) 2 )
, where X all is the size of the global archive X all just before the P-PLS partitioning, σ is the user-set parameter equal to the maximum authorized initial size of a part, and n(n-1) 2 is the number of edges of the addressed MOTSP instance. The smaller σ, the higher RAM needed by P-PLS.

Empirical evidence of global convexity on MOTSP

The aim of this section is to empirically verify the existence of global convexity on MOTSP. To do so, we first check if efficient solutions in the decision space are concentrated in a small fraction of the decision space. Secondly, we check if efficient solutions which are neighbors in the objective space tend to be also neighbors in the decision space.

We check these assumptions on the learning benchmark previously introduced. To find the efficient set of the instances of this benchmark, we run the exact method AUGMECON2 [START_REF] Florios | Generation of the exact pareto set in multi-objective traveling salesman and set covering problems[END_REF] (introduced in Section 2.3.2) on the bi-objective instances of size 100. As suggested by the authors and in Section 2.3.2, AUGMECON2 is unable to find the efficient set of instances of larger size or larger number of objectives, thus we run 2PIPLS/D (using C-LK as SO optimizer) on each instance during several hours with different seeds in order to obtain an approximation of the efficient set.

Proportion of Order of magnitude of efficient edges non-dominated set size p = 2 n = 100 10.5% 10 3 n = 500 2.5% 10 4 p = 3 n = 100 22% 10 5 n = 500 7.5% 10 6

Table 5.2 -Average proportion of edges used in (potentially) efficient solutions and order of magnitude of size of non-dominated sets in function of the number of objectives and the size of instances.

Let the notion of (potentially) efficient solutions encompassing either efficient solutions or approximate efficient solutions.

Concentration of (potentially) efficient solutions in the decision space

To show how much (potentially) efficient solutions are concentrated in the decision space, we are interested in the proportion of edges (which are the basic elements composing solutions of MOTSP) used in (potentially) efficient solutions. Let an efficient edge be an edge present in at least one (potentially) efficient solution of an instance.

The first column of Table 5.2 shows that the (potentially) efficient solutions contain a small fraction of the edges of an instance: from 2.5% (in average) for bi-objective instances of size 500 to 22% (in average) for tri-objective instances of size 100. When considering all instances of the test benchmark, only 11% (in average) of the edges are efficient.

Tri-objective instances have a proportion of efficient edges twice to triple larger than bi-objective instances, which is directly explained by the increase of the size of the non-dominated sets from the bi-objective to the tri-objective case, as indicated by the second column of Table 5.2.

The efficient edges are of very good quality. Let rank(e | χ) be the rank of an edge e ∈ E given the city χ, which is the Non-Dominated Sorting rank (cf. Section 2.4) of the edge e incident to χ, computed with respect to all edges incident to χ and such that the edges are compared through the MO cost function c :

E -→ R p . Let rank(e) = min{rank(e | χ 1 ), rank(e | χ 2 )}
be the rank of the edge e ∈ E incident to both cities χ 1 and χ 2 . Therefore, the rank of an edge e ∈ E is its best rank given its two incident cities, and measures the quality of e. The lower the rank of an edge is, of better quality the edge.

From this formulation of the quality of an edge, we have made an interesting observation concerning the distribution of ranks of efficient edges, illustrated in Figure 5.1. Indeed, the rank of efficient edges is low, and in average on all instances of the benchmark, 96% of efficient edges are of rank lower than or equal to 2, while only 19% of all edges are of rank lower than or equal to 2.

This distribution of ranks of edges leads to a rather neat distinction between efficient edges and the other edges visible in the MO cost space, as illustrated in Figure 5.2. Similar snapshots are obtained in the tri-objective case.

Are (potentially) efficient solutions neighbors in the objective space also neighbors in the decision space?

To check if (potentially) efficient solutions which are neighbors in the objective space tend also to be neighbors in the decision space, we computed the Spearman correlation between:

• the distances of (potentially) efficient solutions (which are tours of MOTSP) in the decision space

• and the distances of their images in the objective space.

The Spearman correlation assesses how well the relationship between two series of data can be described using a monotonic function. The Spearman correlation coefficient can take values between -1 and 1, such that a value of -1 indicates that data series are completely negatively correlated, while +1 indicates that data series are completely positively correlated.

Let X e be the (potentially) efficient set of a given instance. For each (potentially) efficient solution x ∈ X e , let f (x k ) s.t. x k ∈ X e , is the k-th nearest neighbor of f (x) given the Euclidean distance; for each x k ∈ X e , we computed the Hamming distance between x and x k . After averaging and normalizing these distances over all (potentially) efficient solutions and instances of each type, we obtain Figure 5.3. The Spearman correlation computed for each curve is strictly greater than 0.9999. Moreover, given a significance level of 1%, the pvalue related to each Spearman correlation scores is lower than 10 -5 , meaning that the Spearman correlation scores are statistically significant. This means that the distances of solutions and the distances of their images in the objective space are almost perfectly positively correlated.

From these empirical observations, we can conclude that the assumption of global convexity on MOTSP we have made is legitimate, which corroborate the observation made in [START_REF] Borges | A study of global convexity for a multiple objective travelling salesman problem[END_REF].

Parameter setting of 2PIPLS/D

2PIPLS/D has several parameters to set which are listed in Table 5.3. A preselection of alternative values and a selection of the default value for each parameter have been made on the basis of internal tests.

1. As SO optimizer (used by A-MDW and during each perturbation phase of second phase) we propose vanilla C-LK, improved C-LK, (vanilla) NMCS and A-NMCS. We select both the improved C-LK and A-NMCS as default SO optimizers.

2. A-MDW (cf. Section 4.2) is controlled by the minimum acceptance rate threshold α. A-MDW stops as soon as the efficiency of the SO optimizer (i.e. the sum of solutions accepted in the global archive divided by the sum of incomparable solutions generated by each run of the SO optimizer) goes below α.

The lowest α is, more consuming A-MDW will be in terms of computational resources. The preselected range of α goes from 5% to 95% and the default value is 25%.

3. Data perturbation (cf. Section 4.1) is controlled by the coefficient δ. The highest δ is, a more important perturbation will be applied to TSP cost matrices. The preselected range of δ goes from 0% (no data perturbation) to 20% (in general, bad results are obtain with higher values). We select a pretty low default value of data perturbation: δ = 5%.

4. The maximum initial size σ of a part of P-PLS (cf. Section 4.3) corresponds to the maximum authorized initial size of a part at initialization of P-PLS. The preselected range of σ goes from 50 solutions to no partitioning (σ = +∞). The lower bound of the range is limited by the RAM of our machine. The default selected value is σ = 100.

5. The pre-selected maximum neighborhood structure sizes for PLS-VND are k = 2 and k = 3, and both are selected by default.

6. Concerning PLS-VND (cf. Algorithm 32 of Section 4.3), we propose to activate by default all strategies: the independent-pls strategy, meaning that at each iteration of the second phase, PLS-VND is started with an empty global archive; the first-dominating strategy, forcing PLS-VND to quit the exploration of a solution as soon as a neighbor dominates it; and the explore-dominated strategy which enables PLS-VND to explore a solution even if it is dominated by a solution in the global archive. We perform a sensitivity analysis of 2PIPLS/D on its parameters. In particular, we aim at comparing the relative importance of the different algorithmic components of 2PIPLS/D and finally propose a good parameter setting. Given the large number of parameters, we have tested each parameter separately from the other parameters, except for the independent-pls and first-dominating exploration strategies, which have been combined because they are strongly related.

We use the learning benchmark (Section 5.1.2) to perform this sensitivity analysis. On each instance of the benchmark, 2PIPLS/D is run given each alternative value with each possible default combination of values. For example, when the acceptance rate threshold α of A-MDW has been tested, we have run 2PIPLS/D 20 times on each instance: α ∈ {5%, 25%, 50%, 75%, 95%} × SO optimizer∈{improved C-LK, A-NMCS} × k ∈ {2, 3} and the rest of parameters are set to their default values.

The running time of 2PIPLS/D is restricted to high limits: 30 seconds for (p = 2, n = 100) instances, half an hour for (p = 2, n = 500) and (p = 3, n = 100) instances, and 2 hours for (p = 3, n = 500) instances, then the I - H , I and I R2 values of each generated set are computed. In the following, we generally display only the 2PIPLS/D results with C-LK as SO optimizer and k = 3 as PLS-VND maximum neighborhood structure size, because similar conclusions can be drawn when A-NMCS or k = 2 are used instead. For the sake of clarity, only I - H scores are displayed, knowing that same conclusions can be drawn with the other quality indicators. In order to improve the readability of graphics, we have normalized the I - H scores by simply dividing each I - H value by the maximum I - H value found on each type of instance.

Sensitivity analysis of 2PIPLS/D on SO optimizer versions

We compare separately the 2PIPLS/D results with the vanilla version of C-LK vs. the improved version of C-LK illustrated by Figure 5.4, and the vanilla version of NMCS vs. A-NMCS depicted in Figure 5.5.

In both cases, we generally observe a pretty large improvement of the enhanced versions (Improved C-LK, A-NMCS) compared to vanilla version, which attests that memorizing the solutions found during the SO optimizer run is meaningful.

Sensitivity analysis of 2PIPLS/D on A-MDW setting

The influence of the minimum acceptance rate threshold α of A-MDW on the performance of 2PIPLS/D is exposed in Figure 5.6. The lower α is, the more weighted sum problems are solved by A-MDW, and as observed, the later the first phase (A-MDW + P-PLS) of 2PIPLS/D finishes but of better quality the set generated by first phase. Besides, when the number of iterations at second phase grows, this quality difference disappears on small-size instances (n = 100), while it is often maintained on large-size instances (n = 500). This observation reinforces the conclusions of the literature [Lust andTeghem, 2010,Paquete and[START_REF] Paquete | Design and analysis of stochastic local search for the multiobjective traveling salesman problem[END_REF], showing the great importance of initializing PLS-VND with a large number of well-dispersed weighted-sum problems. Globally, good results are obtained when α ≤ 50%, independently from the running time, the type, size or number of objectives of the addressed instance.

Sensitivity analysis of 2PIPLS/D on data perturbation setting

The influence of the data perturbation coefficient δ on the results of 2PIPLS/D is illustrated in Figure 5.7. Globally, the presence of data perturbation (i.e. when δ > 0) seems to have a negligible effect (either positive or negative) on the performance of 2PIPLS/D compared to the absence of data perturbation (δ = 0), except on small-size (n = 100) Euclidean bi-objective instances. On the other hand, a low data perturbation coefficient, i.e. δ ≤ 5% seems to work better on any type of instance compared to larger values.

Sensitivity analysis of 2PIPLS/D on P-PLS setting

The influence of the maximum initial size σ of parts of P-PLS on the results of 2PIPLS/D are shown in Figure 5.8. It is interesting to see that the activation of the partitioning (σ < +∞) improves the anytime behavior of 2PIPLS/D. Firstly, as expected, the partitioning enables to reduce the time of PLS-VND, particularly on large-size instances (n = 500), to the extent that on tri-objective instances of size 500, P-PLS is not even finished when the allocated time is exceeded. Secondly, at a given arbitrary running time, the quality of the generated set is better when the partitioning is activated compared to when it is not, in a great majority of cases. On the other hand, it seems that σ ≤ 100 works well on most instances, with an exception concerning bi-objective Euclidean instances of size 500, where a too small value of σ (i.e. σ = 50) seems to reduce the quality of the generated set. To summarize, σ = 100 obtains the best overall results.

Table 5.4 gathers some key additional information about the impact of the partitioning on the average size of the candidate edge lists managed by PLS-VND and the number of solutions examined by PLS-VND. We recall that each part built by P-PLS has its own candidate edge list associated to each city. First, we can see that the average size of candidate edge lists when the partitioning is activated (σ < +∞) ranges from 1.3 up to 2.6 and is globally stable when the size or the number of objectives grows; while when the partitioning is deactivated (σ = +∞), the average size of candidate edge lists ranges from 5.3 up to 18.9 and grows considerably when the size or the number of objectives grows. Indeed, the partitioning reduces from 78% (when σ = 400) up to 85% (when σ = 50) the size of candidate edge lists. As the size of the candidate edge lists is drastically reduced when partitioning is activated, then the number of solutions examined by PLS-VND is dramatically reduced: from 96.9% (when σ = 400) up to 99.4% (when σ = 50)! Despite this large reduction of exploration of the decision space, Figure 5.8 highlights that the partitioning does not lead to a reduction of the quality of the sets generated if σ is not too small (i.e. σ ≥ 100) regardless of the type, size or number of objectives of the tested instances.

Sensitivity analysis of 2PIPLS/D on PLS-VND setting

We analyze the sensitivity of 2PIPLS/D performance first on the neighborhood structure size of PLS-VND, then on the choice of dependent vs independent PLS-VND, and finally on the different possible combinations of PLS-VND exploration strategies.

Maximum neighborhood structure size of PLS-VND

The comparison between the two alternatives of maximum neighborhood structure sizes (k = 2 or k = 3) is illustrated by Figure 5.9. The performance difference between the two neighborhood structure sizes is often significant for bi-objective instances, while it is generally negligible for tri-objective instances. In both cases, PLS-VND (k = 2) tends to catch up PLS-VND (k = 3) when the number of iterations grows, and this trend is much faster in the tri-objective case.

This reduction of efficiency of PLS-VND (k = 3) compared to PLS-VND (k = 2) when the number of objectives grows can be explained by the fact that PLS-VND is highly sensitive to the number of objectives (as often recalled in the literature -see [Jaszkiewicz, 2017] for example). By extension, a larger neighborhood structure is even more sensitive to an increase of the number of objectives. On the other hand, the optimization of weighted sum problems -what does the perturbation step of 2PIPLS/D-is much less sensitive from an increase of the number of objectives than PLS-VND. Consequently, the global idea is that when the number of objectives grows, the efficiency of PLS-VND decreases to the benefit of the perturbation phase. In addition, it turns out that PLS-VND (k = 2) consumes much less computational resources than PLS-VND (k = 3), -70% in average over all types of instances, as indicated in Table 5.5. This saving allows 2PIPLS/D with PLS-VND (k = 2) to reallocate more computational resources on the perturbation step, and thus on weighted-sum optimizations.

Dependent vs. independent PLS-VND

The comparison between 2PIPLS/D with dependent PLS-VND and 2PIPLS/D with independent PLS-VND is depicted in Figure 5.10. There is no neat performance difference between the two alternatives, except on bi-objective Euclidean instances, where independent PLS-VND obtains better results.

It is interesting to note that these two alternatives induce drastically different allocations of computational resources during a run of 2PIPLS/D. Indeed, as independent PLS-VND takes as parameter an empty global archive, each independent PLS-VND consumes much more computational resources than a run of dependent PLS-VND, +717% in average over all types of instances, as suggested in Table 5.6.

Exploration strategies of PLS-VND

Figure 5.11 displays the performance of 2PIPLS/D with the four combinations of exploration strategies of PLS-VND. We can see that the selection of a given combination of exploration strategies does not influence the performance of 2PIPLS/D, with the exception of the (First dominating+Explore dominated) combination which outperforms the other combinations on small-size (n = 100) bi-objective Euclidean instances.

Final parameter setting of 2PIPLS/D

In consequence of the different analysis previously made in this section, we propose two final parameter settings of 2PIPLS/D (summarized in Table 5.7), diverging only on the SO optimizer used: the first version of 2PIPLS/D uses improved C-LK and the second uses A-NMCS. Table 5.7 also displays a ranking of the parameters in function of their influence on 2PIPLS/D performance.

Comparison of 2PIPLS/D with state-of-the-art methods

2PIPLS/D will now be compared to the best known methods of the literature. To do so, 2PIPLS/D follows the parameter setting described in Table 5.7 such that two versions of 2PIPLS/D are considered:

• 2PIPLS/D with C-LK as SO optimizer;

• and 2PIPLS/D with A-NMCS as SO optimizer.

The running time of 2PIPLS/D will be limited to the minimum running time between all its competitors. Let us first present the selected competitors and a number of additional implementation information, then describe the results of our experiments.

Selection of competitors

The competitors we have chosen have already been described in Section 2.3.2 when we made a literature review for MOTSP. As the most advanced exact method of the literature, we selected AUGMECON2 [START_REF] Florios | Generation of the exact pareto set in multi-objective traveling salesman and set covering problems[END_REF]. Given its limitations already mentioned, we have run AUGMECON2 only on biobjective instances of size 100. We use the executable implemented by the authors and available online6 . Globally, 2PIPLS/D with C-LK obtains good results. Concerning bi-objective instances of size less than or equal to 100, when the 20 runs of the method are merged together, at least 99% of the (approximate) nondominated points are found (i.e. coverage is greater than or equal to 99%). In particular, 2PIPLS/D is the only meta-heuristic which was able to find the (exact) non-dominated set of some instances (7 bi-objective instances of size 100 over 16). For comparison, AUGMECON2 is an exact method and therefore finds the (exact) non-dominated set of all bi-objectives instances of size 100 in slightly less than 30 hours in average, while 2PIPLS/D finds at least 99% of the non-dominated points in less than 4 minutes in average.

Over all quality indicators and all tested instances, 2PIPLS/D (with C-LK) outperforms both

MoMad and PD-TPLS. Indeed, 2PIPLS/D (with C-LK) has a strictly better average performance than both MoMad and PD-TPLS and the Mann-Whitney test (cf. Section 2.1.4) confirms that 2PIPLS/D is strictly better than both MoMad and PD-TPLS. In a great majority of cases, for a given quality indicator on a given instance, the worst run of 2PIPLS/D (with C-LK) is better than the best run of MoMad or PD-TPLS. Moreover, the worst I average value of 2PIPLS/D over all tested instances is (slightly less than) 5%, meaning that 2PIPLS/D is able to provide for all tested instances an -approximation of very good quality. In comparison, the best competitor (PD-TPLS) proposes a worst I average value of 11%.

Over all quality indicators and tested instances, 2PIPLS/D (with C-LK) outperforms PDA, except for 3 instances (over 55). Indeed, the Mann-Whitney test indicates that 2PIPLS/D is strictly better than PDA over all instances except on: kroAB300 over I , ClusterAB500 over I and I R2 and kroAB750 over I , for which 2PIPLS/D and PDA are considered as equivalent.

Besides, 2PIPLS/D with A-NMCS provides very poor performance, except on tri-objective instances of size lower than or equal to 100 (Tables 5.12 and 5.14). In particular, its performance worsen when the size of the instance grows. This confirms the fact that construction-based heuristics are generally not efficient on large-size MOTSP instances. Indeed, the same observation can be made for Ant Colony Optimization solver [START_REF] López-Ibáñez | The automatic design of multiobjective ant colony optimization algorithms[END_REF]. This also shows the major influence of the SO optimizer on It is interesting to see that all meta-heuristics (2PIPLS/D, PDA, MoMad, PD-TPLS) obtains much better results on non-random instances compared to random ones. As examples:

• On the bi-objective Euclidean instance kroAB500 (Table 5.10), 2PIPLS/D (with C-LK) obtains an average I value of 0.06%, and MoMad 0.22%; on the other hand, on the bi-objective random instance rdAB500 (Table 5.11), 2PIPLS/D (with C-LK) obtains an average I value of 1.22%, and MoMad 2.90%.

• On the tri-objective Euclidean instance euclidABC500 (Table 5.13), 2PIPLS/D (with C-LK) obtains an average I value of 1.3%, and MoMad 4.1%; on the other hand, on the tri-objective random instance rdABC500 (Table 5.14), 2PIPLS/D (with C-LK) obtains an average I value of 4.7%, and MoMad 26.5%.

This effect can be explained by the fact that C-LK (which is the solver used by all the meta-heuristics except 2PIPLS/D with A-NMCS) is particularly efficient on instances where the triangular inequality holds (Euclidean and clustered instances), but has difficulties on instances where the inequality does not hold (which is the case on random instances).

Note that the size of the approximate non-dominated set Y nd strongly grows with the instance size n and the number of objectives p, reaching at least 1.1 million points for tri-objective random instances of size at least 300 (Table 5.14). For tri-objective instances of size n ≥ 100, the approximation sets found by the methods are much smaller than Y nd . This is due to the use of -archive with = 1%, which bounds the size of the approximation while preserving a good distribution of the points in the objective space. Indeed, results of 2PIPLS/D (with C-LK) are still of good quality. One can consider the instance rdD-3-500 (Table 5.14), for which 2PIPLS/D (with C-LK) has its worst I results. On this instance, the approximations generated by 2PIPLS/D (with C-LK) is worse than Y nd by only a factor of 4.98% (in average), indicating that 2PIPLS/D (with C-LK) generates well dispersed approximation sets over Y nd .

Figure 5.20 highlights the number of solutions examined by 2PIPLS/D (with C-LK), PDA, MoMad and PD-TPLS. First, it is important to indicate that PLS-VND provides more than 99% of the solutions examined by 2PIPLS/D, the rest being provided by the SO optimizer. On bi-objective instances, 2PIPLS/D (with C-LK) examines much less solutions than its competitors, and the gap grows significantly as the instance size grows. This observation is particularly interesting as 2PIPLS/D uses a 3-exchange as PLS-VND neighborhood, while its competitors only use a 2-exchange neighborhood in their PLS and obtain worse results, which shows the efficiency of the partitioning system of P-PLS.

On tri-objective instances, 2PIPLS/D (with C-LK) does not examine less solutions than PDA and MoMad, however the number of solutions examined by 2PIPLS/D increases slower than for its competitors when the instance size grows. On the other hand, it is interesting to note that while PD-TPLS runs a single iteration of PLS with a 3-opt, it already examines much more solutions than the other methods. This is due to the fact that the candidate edge list used by PD-TPLS is not adapted, contrary to the one used by 2PIPLS/D. This remark points out the difficulty of designing an efficient PLS using a neighborhood larger than 2-exchange neighborhood for MOTSP. A final comment can be made on RAM usage of 2PIPLS/D. Despite the fact that the partitioning brought by P-PLS is intended to increase drastically the RAM usage compared to no partitioning (as mentioned in Section 5.2.4), 2PIPLS/D generally consumes twice less RAM than its competitors. This is due to a trick we propose, the so-called lazy RAM management, which consists in loading on memory only the edges effectively used during PLS-VND. Figure 5.21 shows the differences in terms of RAM consumption of partitioning, between vanilla RAM management and lazy RAM management.

Conclusion

In this chapter, we first proposed an implementation of the different components of 2PIPLS/D, in particular we proposed to use C-LK and A-NMCS as SO optimizers, and suggested an implementation of the neighborhood restriction structure for P-PLS. Then, we presented an empirical evidence of global convexity on MOTSP in order to legitimate the use of the P-PLS partitioning system. We found that (potentially) efficient solutions are effectively concentrated in decision space and that (potentially) efficient solutions neighbors in the objective space tend to be also neighbors in the decision space. After a sensitivity analysis of 2PIPLS/D on its parameters, we ranked the different parameters in function of their influence on the performance of the method. We found that 2PIPLS/D is sensitive to the number of weighted-sum problems solved at initialization during A-MDW, and the maximum authorized size of a part at P-PLS initialization. In particular, we have noted that P-PLS reduces drastically the number of solutions examined by PLS-VND (-98% in average over the instances tested) thanks to its partitioning system. In addition, memorizing the solutions during the run of a SO solver appears to be highly effective, for both C-LK and A-NMCS. In addition, 2PIPLS/D seems moderately sensitive to the maximum neighborhood structure size.

On the other hand, 2PIPLS/D seems not to be particularly sensitive to data perturbation and to the different exploration strategies and mods used by PLS-VND. Finally, we compared 2 versions of 2PIPLS/D (either with improved C-LK or A-NMCS) to the best current methods on a large benchmark of bi-objective and tri-objective instances.

2PIPLS/D (with C-LK) obtains good results and found the exact non-dominated set of 7 bi-objective instances of size 100 over 20 runs, so that 2PIPLS/D is, to our knowledge, the first meta-heuristic able to find non-dominated set of MOTSP instances of such size. 2PIPLS/D (with C-LK) outperforms MoMad and PD-TPLS on all tested instances; 2PIPLS/D also outperforms PDA on 95% of the tested instances and has equivalent performance on the 5% remaining instances.

Finally, 2PIPLS/D with C-LK outperforms in a great majority of cases 2PIPLS/D with A-NMCS, which strengthens the fact that 2PIPLS/D performance highly depends on the efficiency of the SO solver.

Concerning perspectives, it could be interesting to implement neighborhood structures for PLS-VND of larger size than 3-exchange, or even better, to propose variable k-exchange moves like in Lin-Kernighan. However, we can enumerate two main limitations about this perspective. Firstly, as already mentioned in Section 2.3, the techniques which made LS-based methods so powerful on TSP, like don't-look-bits or candidate edge lists, are not as far as efficient in MOTSP. Secondly, it seems that the global perturbation step of 2PIPLS/D is sufficiently efficient to compensate a small PLS-VND neighborhood structure size.

A second perspective is the application of 2PIPLS/D on larger instances, both in terms of sizes and number of objectives. According to us, the main limitation concerning this proposal is that 2PIPLS/D, like any method based on the 2-phase PLS framework, are highly sensitive to the SO optimizer employed to (re-)start PLS. However, Lin-Kernighan-based SO optimizers seems to be the best option we currently have, but are not so efficient on instances in which the triangular inequality does not hold. Therefore, we expect difficulties for this type of methods on random instances, like bi-objective or tri-objective of size 1000, or on large-scale four-objective instances.

Chapter 6

Application of 2PIPLS/D to MOFRMP

This chapter introduces a new five-objective real-world problem called MO French Regions Mapping Problem (MOFRMP). It is related to the recent territorial reform of French regions which resulted in the reassignment of departments to new larger regions. The aim of this problem is to find a map (i.e. an assignment of departments to regions) optimizing five objectives, which evaluate the strength of interactions between the departments assigned to the same region, as well as the economical and demographic weights of each region. We propose to apply 2PIPLS/D to this problem. We first present an implementation of 2PIPLS/D, then we study the existence of global convexity on MOFRMP. After a sensitivity analysis on its parameters, we compare several versions of 2PIPLS/D with different parameter settings and discuss about the results.

Introduction

This chapter introduces the MO French Regions Mapping Problem (MOFRMP), a new five-objective realworld problem falling within the scope of the recent territorial reform of French regions which resulted in the reassignment of departments to new larger regions. Firstly, Section 6.1 presents MOFRMP, then Section 6.2 proposes an implementation of 2PIPLS/D and Section 6.3 studies the global convexity on the problem.

Computational experiments are performed on Section 6.4, and the results are discussed in Section 6.4.2. Finally, we summarize the chapter and propose some perspectives concerning MOFRMP.

Presentation of MOFRMP

Metropolitan France is the part of France located in Europe. It is composed of 96 administrative divisions, called departments. Each department belongs to a higher-level administrative division called region.

In January 1 st , 2016, a new administrative map of Metropolitan France has taken effect (the so-called current map), grouping departments into larger regions and reducing the number of regions from 22 down to 13. Figure 6.1 illustrates the 12 regions (excluding Corsica island), their respective capital and departments, and Table 6.1 lists them.

This historical territorial reform takes place within a larger process called decentralization, consisting in transferring administrative powers from the French State to local entities distinct from it, making the regions more autonomous from Paris1 and registered in the French Constitution since 20032 .

Officially, two main reasons drive this regrouping of the departments into larger regions 34 :

1. Reducing the administrative complexity and thus the surcharge in terms of operating cost, the socalled "millefeuille administratif" in French, for both, French and foreign, individuals and companies, by making economies of scale and simplify the administrative procedures.

2. Increasing the exposure, the attractiveness and competitiveness of the French regions within both European and international spheres by increasing their economical power.

However, it has been recognized5 that some departments are attracted to regions other than their current region of assignment. The current map of regions can therefore be potentially improved. But further research is needed to address this problem.

This is why from 2016 to 2019, departments attracted by another region than their current region of assignment have the possibility to launch a procedure to change to another region if both regions give their support6 .

The different criteria that assess the attraction of a department to a given region are complex and of multiple natures: economic, financial, social, cultural, environmental, but we will only consider here the criteria proposed by a recent economic analysis of this problem [START_REF] Amabile | Une évaluation de la cohérence économique interne des régions[END_REF] France Stratégie8 is an institution attached to the government, whose objective is to contribute to determine the main orientations for the future of the nation and the medium-term and long-term objectives of its economic, social, cultural and environmental development, as well as the preparation of reforms.

This analysis identified 5 objectives (or criteria) divided in two groups, to evaluate the assignment of departments to a given region. The first group of objectives (the so-called travel times to regional capitals, inter-departmental commuting intensities, inter-departmental shareholding intensities objectives, described below) proposes to assign to the same region, departments that have strong economic links in order to ensure a greater regional economic coherence. The second group of objectives (the so-called regional GDP weights, regional population weights objectives, described below) aims at building regions whose economic and demographic roles are not too heterogeneous, to ensure that each region has sufficient resources to carry out economic development policies and to cope with the fixed costs of regional administration.

From this analysis, we introduce the subsequent new MOCO problem, called MO French Regional Mapping Problem (MOFRMP). It consists in building a so-called map (of regions), i.e. an assignment of each department of Metropolitan France (except Corsica island -departments 2A and 2B-forming the Corsican Territorial Community) to a region, such that two constraints are satisfied:

• the constraint of fixed capitals: the departments containing a regional capital are fixed (departments 13, 21, 31, 33, 35, 44, 45, 59, 67, 69, 75, 76);

• and the constraint of regional continuity: a region forms a block of departments such that there is no discontinuity of the regional territory (in other words: there is no departments isolated from their regional capital).

while optimizing the 5 objectives previously mentioned: (1) travel times to regional capitals, (2) interdepartmental commuting intensities, (3) inter-departmental shareholding intensities, (4) regional GDP weights, (5) regional population weights.

More formally, a feasible solution (a map) is represented by a vector x = (r(1), ..., r(19), r(21), ..., r( 95)) ∈ X, where r(i) ∈ R represents the assignment of department i to the region r(i) (identified by the code of the department containing its capital), where R = {13, 21, 31, 33, 35, 44, 45, 59, 67, 69, 75, 76} is the set of departments containing a regional capital (|R| = 12), for each i ∈ D where D = {1, ..., 19, 21, ..., 95} is the set of departments (|D| = 94), while satisfying:

• the constraint of fixed capitals: r(j) = j for each department j ∈ R;

• and the constraint of regional continuity: for any department d 1 ∈ D such that r(d 1 ) = j, there is a path of departments (d 1 , ..., d K , j) such that for each k = 1, ..., K, r(d k ) = j and departments d k and d k+1 are adjacent (assuming d K+1 = j).

MOFRMP is defined by (1.1) with p = 5 and such that X is the set of maps:

min f (x) = (f 1 (x), ..., f 5 (x)) subject to x ∈ X
where the objective function f is composed of the five following single-objective functions:

1) The sum of travel times to regional capitals (to be minimized):

For each region, the time to travel by car from a department to its regional capital is considered as an indication of the ability of local government to get information about demand, preferences and production costs for goods and services that are provided by the local government. A higher travel time between a department and the regional capital reduces the informational advantage of the local government. This loss of efficiency is supposed to be quadratic with travel time. For each region is computed the population 9weighted average of the squared travel time from the capital of the department to the regional capital. After summing over all regions, we obtain the following formula:

f 1 (x) = r∈R d∈Dr(x) pop d × (time d,r ) 2
where D r (x) is the set of departments assigned to the region r ∈ R in the map x, pop d is the population of department d ∈ D, time d,r is the average time to travel from the department d to the capital of the region r.

2) The sum of inter-departmental commuting intensities (to be minimized):

This objective uses an indicator 10 proposed in [START_REF] Amabile | Une évaluation de la cohérence économique interne des régions[END_REF] which measures the intensity of commuting between two departments of the same region. The indicator value ranges from 0.0 to 1.0 (lower is better), such that a value of 1.0 means no people travel between the two departments. For each region, the second objective is computed as the average indicator value over all ordered pairs of departments of the region. The aim is to favor the grouping in the same region of departments between which these commuting links are strong. After summing over all regions, we obtain the following formula: 3) The sum of inter-departmental shareholding intensities (to be minimized):

f 2 (x) =
This objective uses an indicator11 proposed in [START_REF] Amabile | Une évaluation de la cohérence économique interne des régions[END_REF] which measures the intensity of financial exchanges between two departments of the same region, measured by the shareholding of a department in the companies of another department. The indicator value ranges from 0.0 to 1.0 (lower is better), such that a value of 1.0 means no shareholder link between two departments. More the shareholders of a department control a high percentage of jobs in the other department, the lower the indicator will be. For each region, the third objective is computed as the average indicator value over all ordered pairs of departments of the region. The aim is to favor the grouping in the same region of departments between which these financial links are strong. After summing over all regions, we obtain the following formula:

f 3 (x) = r∈R d∈Dr(x) d ∈Dr(x) : d >d f in d,d |D r (x)| (|D r (x)| -1) /2
where f in d,d is the intensity indicator value of shareholding between department d and department d .

4)

The sum of regional GDP weights (to be minimized):

This objective uses an economic indicator12 proposed in [START_REF] Amabile | Une évaluation de la cohérence économique interne des régions[END_REF] which measures the GDP weight of a department. The indicator value of a department consists in the standardized GDP score of the department. For each region, the fourth objective considers the inverse squared sum of indicator value over all departments. The aim of this objective is to build regions whose economic roles are not too heterogeneous. After summing over all regions, we obtain the following formula:

f 4 (x) = r∈R    1 d∈Dr(x) gdp d    2
where gdp d is the GDP score of the department d.

5) The sum of regional population weights (to be minimized):

This objective uses a demographic indicator 13 proposed in [START_REF] Amabile | Une évaluation de la cohérence économique interne des régions[END_REF] which measures the population weight of a department. The indicator value of a department consists in the standardized population score of the department. For each region, the fifth objective considers the inverse squared sum of indicator value over all departments. The aim of this objective is to build regions whose demographic roles are not too heterogeneous. After summing over all regions, we obtain the following formula:

f 5 (x) = r∈R    1 d∈Dr(x) pop d    2
where pop d is the population score of the department d.

An important remark can be made on [START_REF] Cazenave | Optimizing french regions[END_REF]. In this paper, Cazenave, Bernard and Épaulard propose to optimize the so-called original FRMP, which follows another formulation of the FRMP than the one we present. While the constraints of the problem are exactly the same, the problem is considered as a single objective problem such that the function to optimize is a weighted sum of the objectives, and the authors solve the problem with different weights. Furthermore, the objectives of the problem are different as the authors consider only the four following objectives:

• the three first objectives we consider: (1) travel times to regional capitals, (2) inter-departmental commuting intensities and (3) inter-departmental shareholding intensities;

• the fourth objective, called political preferences heterogeneity, is different from the ones we consider and consists in minimizing the heterogeneity of political preferences (computed with the results of presidential elections) between the departments assigned to the same region.

In our MO formulation, we do not consider this additional objective (the political preferences) because after some discussions with A. Épaulard, it appears to us that this objective was probably not consistent with the problem.

On the contrary, according to us, the two last objectives we consider in MOFRMP (and not considered in the original FRMP), the (4) regional GDP weights and (5) regional population weights, are essential. In fact, a region is responsible for economic development policies and essential public services -mainly transports, education, employment-and has to cope with the fixed costs of administration. So a region has important financial needs. Taxes levied to the population (local taxes and property tax among others) and companies (property tax) allow to finance a part of the needs14 . Therefore it appears important to consider the (5) population weights as an objective, in order to build regions with a demographic disparity as low as possible. Furthermore, in the draft finance bill for 201715 , the State-financed Regional Operating Fund (Dotation Globale de Fonctionnement, in French) must disappear and be replaced by the transfer of a fraction of the Value-added tax (VAT -TVA in French). Given that VAT is globally proportional to the GDP, the (4) GDP weights objective seems also important to be optimized, in order to obtain regions with economic roles not too heterogeneous. Finally, it is important to know that France suffers from massive unemployment for many years now, its reduction becoming a National priority for the successive governments. The regions are therefore in competition to attract companies, and in order to encourage them to establish at home, the regions are investing considerable sums of money through regional investment funds (e.g. Normandie Participations16 for the Normandie region) to provide companies with an access to substantial financial or material support for business development.

Consequently, it appear to us that regions with GDP and population disparities as low as possible, and thus a low disparity in terms of income between the regions, could make the competition as fair as possible to reduce unemployment and keep good public services in all regions in an homogeneous way; making essential to consider the (4) regional GDP weights and the (5) regional population weights objectives in MOFRMP.

Implementation of 2PIPLS/D to address MOFRMP

As a component-wise method, 2PIPLS/D contains several algorithmic components to implement for MOFRMP: the elementary LS move, the neighborhood structure utilized by PLS-VND, the neighborhood restriction structure used in P-PLS, the perturbation move and the SO optimizer. Given the high number of objectives of the problem, the non-dominated set is certainly extremely large, consequently the archives of 2PIPLS/D are managed as -archives with SANDRA and a tolerance for dominance relations = 1% is used. Let us present more precisely the implementation of 2PIPLS/D.

Local Search-oriented components

The most essential algorithmic component is the elementary LS move, the so-called k-department move.

It consists, from a given feasible map, to select k departments and for each department, choosing a target region different from the region it belongs to, such that the modified map is still feasible. The parameter k is called the size of the move.

The neighborhood structure for PLS-VND is a k-department neighborhood and we consider different maximum neighborhood structure sizes k = 1, 2, 3. Obviously, PLS-VND with k = 1 corresponds to PLS.

The neighborhood restriction structure, employed in the parts of P-PLS, consists in computing for each part the set of locked departments, i.e. the set of departments assigned to the same region in all solutions in the archives of the sources of this part, and forbidding during PLS-VND the reassignment of any locked department.

Concerning the perturbation move used at perturbation step (second phase), internal tests have shown that using a 10-department move obtains stable and good results.

SO optimizer

The SO optimizer is used in A-MDW and during the perturbation step (second phase). A selection of 3 SO optimizers has been made.

Iterated Local Search (ILS)

We have implemented an ILS with Variable Neighborhood Descent (VND) and able to memorize all incomparable locally minimum solutions generated (as suggested in Section 4.1). Except the starting solution, ILS has three input parameters whose values have been set through internal tests: a number of iterations set to 100, a VND using k-department neighborhood with a maximum neighborhood structure size of 2, and a 10-department move as perturbation move.

A-NMCS

Cazenave has implemented an NMCS optimizing a weighted sum of MOFRMP objectives. We have converted it into A-NMCS by:

• memorizing all incomparable generated maps;

• managing the optimization of a data perturbed weighted sum problem;

• taking an initial map and its associated sequence as input parameters at the highest nested level.

In A-NMCS, the construction of a sequence consists in building a map by iteratively assigning a department to a region. More precisely, let a feasible partial map be a map such that a number of departments are not yet assigned to a region, but such that the constraint of fixed capitals is satisfied and the constraint of regional continuity can still be satisfied if the partial map is completed. An action consists in assigning to a region the department with the lowest code among all unassigned departments, while the obtained map is still feasible. Therefore, a (partial) sequence consists in an ordered list of assignments.

At a level of recursion greater than or equal to 1, A-NMCS tries all available actions. In random simulations, actions are selected uniformly at random. We found that A-NMCS with a level of recursion equal to 1 provides poor results, while A-NMCS of level 3 conducts very long runs, thus we choose level 2.

Iterative Deepening A* (IDA*)

IDA* [Korf, 1985] is an exact solver based on the Branch-and-Bound methodology using a problem-specific admissible heuristic to bound search sub-spaces. Cazenave has implemented an IDA* for the studies [START_REF] Amabile | Une évaluation de la cohérence économique interne des régions[END_REF],Cazenave et al., 2016] 17 (in French). This method is able to optimize a weighted sum of all the six objectives previously described: the five objectives of MOFRMP, and the political preferences heterogeneity objective.

It has been employed to solve the original FRMP (previously introduced). Efficient admissible heuristics have been found and enable IDA* to solve any tested weighted sum aggregation of the four objectives of the original FRMP in few seconds. On the other hand, the admissible heuristics for the two remaining objectives (both considered in MOFRMP): the (4) regional GDP weights and the (5) regional population weights objectives, have not already been tested.

Study of global convexity on MOFRMP

As no exact method has been implemented for MOFRMP, we do not know its efficient set. We have merged all approximation sets generated during experiments and internal tests to produce an approximation of the efficient set. The study presented in this section is based on this approximation set. Let the (potentially) efficient solutions be the solutions of this approximation set. Note that this work might be biased by the efficiency of 2PIPLS/D on this problem, despite the large number of 2PIPLS/D runs and settings tested.

The aim of this section is to empirically study global convexity on MOFRMP. Firstly, we check if (potentially) efficient solutions which are neighbors in the objective space tend to be also neighbors in the decision space. Secondly, we analyze the concentration of (potentially) efficient solutions in the decision space.

Are (potentially) efficient solutions neighbors in the objective space also neighbors in the decision space?

To check if (potentially) efficient solutions which are neighbors in the objective space tend also to be neighbors in the decision space, we follow the same process as in Section 5.3.2 for MOTSP and compute the Spearman correlation between the distances of (potentially) efficient solutions in the decision space, and the distances of their images in the objective space. We obtain a Spearman correlation value equal to 0.989202. Given a significance level of 1%, the p-value related to the Spearman correlation score is lower than 10 -5 , meaning that the Spearman correlation score is statistically significant. This means that the distances of solutions and the distances of their images in the objective space are almost perfectly positively correlated.

Concentration of (potentially) efficient solutions in the decision space

The assignment of a department d ∈ D to a region r ∈ R represents the basic element composing the solutions of MOFRMP. We have computed the proportion of all possible assignments (department, region) of MOFRMP used in (potentially) efficient solutions, in order to see how much they are concentrated in the decision space. In fact, the (potentially) efficient solutions contain 52% of all possible assignments (in average each department is assigned to 6.2 regions over 12). This corresponds to a large fraction of all possible assignments, in comparison of the 11% of edges used in average on MOTSP instances tested in Section 5.3.1. Thus we can say that the (potentially) efficient solutions are not particularly concentrated in the decision space. As a consequence, the intersection between solutions (i.e. the number of departments in D \ R assigned to the same region in all these solutions) neighbors in the objective space decreases exponentially fast as the distance (in the objective space) grows, as illustrated in Figure 6.2. In particular, the intersection goes below the 40% between 100 solutions and below 24% between 1000 solutions. Therefore, it is expected that the partitioning system of P-PLS may not be so useful and not as efficient as in MOTSP.

Experiments

In this section, we first analyze the influence of the parameters on the performance of 2PIPLS/D, then we discuss about the results.

Sensitivity analysis of 2PIPLS/D on its parameters

We carried out a sensitivity analysis of 2PIPLS/D on its parameters. Table 6.2 lists the parameters and their respective range of values, preselected after a number of internal tests. We will focus here only on the most important results. Each version of 2PIPLS/D with a given combination of parameter values has been run 10 times and the I - H , I and I R2 values of each approximation set has been computed. For the sake of clarity, only I - H scores are displayed, knowing that same conclusions can be drawn with the other quality indicators. Except when IDA * is employed as SO solver, the running time of 2PIPLS/D is limited to 3 hours. Note that we have tested internally 2PIPLS/D with a running time of 6 hours and results do not change significantly. First of all, running 2PIPLS/D with IDA* as SO optimizer achieved poor performance. While each IDA* run was limited to 1 hour, not a single run found any efficient solution. 2PIPLS/D remained stuck at A-MDW and we stopped 2PIPLS/D after a whole day of execution. Therefore, we will not consider anymore IDA* in the rest of this chapter.

Secondly, like in MOTSP (see Section 5.4.2), an acceptance rate threshold α of A-MDW set to 25% provides good results, whatever the SO optimizer used (either ILS or A-NMCS) in 2PIPLS/D. Thirdly, like in MOTSP (see Section 5.4.5), we found that any combination of exploration strategies of PLS-VND (without/with first-dominating strategy and ignore/explore-dominated strategy) provide very similar results. Their influence on 2PIPLS/D is therefore negligible and we activate both strategies.

The comparison between 2PIPLS/D with ILS (and a maximum neighborhood structure size k = 2) and 2PIPLS/D with A-NMCS (and k = 2) is illustrated in Figure 6.3(a). While a single run of ILS is 15 times faster (in average) than an A-NMCS run, 2PIPLS/D with ILS outperforms 2PIPLS/D with A-NMCS. Similar results are obtained with k = 1. As a consequence, the remaining results will only consider 2PIPLS/D with ILS as SO solver. Figure 6.3(b) shows the performance of 2PIPLS/D with data perturbation (δ = 5%, k = 1, 2) and without (δ = 0%, k = 1, 2). It seems that the presence of data perturbation has a negative impact on 2PIPLS/D performance, either for k = 1 or k = 2. This highlights the fact that optimizing a perturbed weighted-sum problem is quite hazardous. Indeed, as mentioned in [START_REF] Cornu | Perturbed decomposition algorithm applied to the multi-objective traveling salesman problem[END_REF], there is no guarantee that the optimal solution of a data perturbed weighted sum problem is efficient for the addressed MO problem. Therefore, solving a perturbed weighted sum problem may not produce any efficient solution, contrary to a non-perturbed weighted-sum problem which is therefore safer to optimize. Typically, on MOTSP, C-LK is so efficient that it generally finds in a single run the optimal solution of a non-perturbed weighted sum problem on small-size Euclidean instances. In consequence, C-LK quickly finds a large portion of the supported solutions of such instances. Because supported solutions are generally far fewer than nonsupported solutions, data perturbation is welcome in such instances (as seen in Section 5.4.3) because it brings the ability to C-LK (or any other SO solver) to find non-supported solutions, and thus restores the utility of C-LK. On the other hand, our ILS is not as efficient on MOFRMP as C-LK on small-size Euclidean instances. Consequently, it seems safer to optimize non-perturbed weighted-sum problems.

As expected, the partitioning system of P-PLS is not as efficient as for MOTSP, as shown in Figure 6.4(a), Concerning the maximum neighborhood structure size k used in PLS-VND, Figure 6.4(b) shows that k = 2 is the best alternative given the total execution time imposed (3 hours for each run), as k = 1 finds poorer results while k = 3 is too time consuming.

Finally, in Figure 6.4(c), we can see that using PLS-VND in Dependent mod stops improving very early (from 2 hours of running time). This shows the utility to rediscover the search space with PLS-VND with a different starting set of solutions each time, like the PLS-VND in Independent mod does.

Discussion about the results

After merging and filtering all solutions generated by the different 2PIPLS/D runs, we found 248,794 (potentially) efficient maps.

Before attempting to propose a map as an alternative to the current map (Figure 6.1) among the (potentially) efficient maps, it seems important to indicate that all the (potentially) efficient maps have at least 18 departments assigned to a region different from their current region of assignment. Figure 6.5 illustrates a map with 18 assignments of departments different from the current map and dominating it. Knowing this, it seems difficult to propose any of these (potentially) efficient maps as an alternative. Indeed, it is very likely that any decision-maker will reject any of these alternative maps since the political and structural changes induced by a reassignment of at least 18 departments (over 82) are probably unacceptable in real life. Therefore, instead of suggesting an alternative map, we propose to identify which departments are more attracted to other regions than the one they are assigned to in the current map. To do that, we will use the (potentially) efficient maps found.

Since the decision-makers are members of the government, or at least their closest advisers in the state apparatus, we do not have access to their preferences concerning the relative importance between the objectives. Besides, in order to avoid making any compromise between the objectives, we decided to consider only the (potentially) efficient maps which dominate the current map, which are 4913 -representing 2% of all (potentially) efficient maps-.

From this reduced set of maps, we compute the so-called membership score of each department, where the membership score of a department d ∈ D is the number of solutions of the reduced set in which d is assigned

Conclusion

In this chapter, we are interested in the recent territorial reform of French regions which resulted in the reassignment of departments to new larger regions. Starting by the observation that some departments are attracted to other regions than their current region of assignment, the aim of this chapter was to attempt to identify such departments through the optimization of a new many-objective real-world problem called MOFRMP. The problem consists in finding alternative maps optimizing five objectives based on economical and financial indicators measuring the strength of interactions between the departments assigned to the same region, as well as the economical and demographic weights of each region. We applied 2PIPLS/D to this problem and tested ILS and A-NMCS as SO solvers. We found that 2PIPLS/D with ILS outperforms 2PIPLS/D with A-NMCS. An approximation of the efficient set has been generated with the different runs of 2PIPLS/D. However, we found that the (potentially) efficient maps found have far more departments of difference with the current map, making unrealistic to propose them as alternative of the current map. Instead, we built an indicator based on the found approximation set which aims at identifying the departments the most attracted by other regions than the current they are assigned to. In particular, we found that Gard (30), Haute-Marne (52) and Deux-Sèvres (79) are particularly attracted to other regions.

MOFRMP raises an important question: could the current map of regions be improved? The work proposed in this chapter corresponds only to a preliminary answer to this question. We believe that a new formulation of MOFRMP is necessary for obtaining realistic alternative maps. Firstly it seems to us important not to restrict this problem to economic and financial criteria only. As examples, the cultural exchanges between departments could be considered, or the global intensity of movements of people between the departments, not only commuting. Secondly, it is imperative to obtain the preferences of the decision-makers about the relative importance of the different criteria considered. Thirdly, we think that any alternative map has to propose a very limited number of reassignments of departments compared to the current map. If the maximum number of reassignments is limited to 3 or 4 for example, the problem becomes quite easy and it seems that no optimization method is needed. Indeed, in this case, a simple enumeration of the solutions is necessary, finally a filtering to keep only efficient solutions, then applying a Multiple Criteria Decision Aid method with the preferences of the decision-makers previously retrieved. On the other hand, if a higher number of reassignments is accepted (i.e. 5 or higher), the number of feasible solutions seems too large for enumeration. In this case, a MO optimization method is necessary and 2PIPLS/D could be adapted to this new formulation of MOFRMP.

Conclusion

Falling in the scope of Multi-Objective Combinatorial Optimization (MOCO), this thesis proposed a number of new approximation methods and data structures for large-scale MOCO problems. Firstly, the contributions of the thesis are summarized, then a number of perspectives are suggested.

Contributions

1. We proposed two new archives: AVL-Archive for the bi-objective case and NDR * -Archive for any number of objectives; as well as their self-adjusting versions using the concepts of temporal and spatial locality, and thus especially designed for Pareto Local Search (PLS): Self-Adjusting AVL-Archive (SAAVLA) and Self-Adjusting NDR * -Archive (SANDRA). We compared these archives to state-of-theart archives and we obtain better results than competitors on all tested instances, making AVL-Archive, NDR * -Archive and their self-adjusting versions the most efficient archives up to 5 objectives.

2. We presented a new method generalizing the concept of Maximally Dispersed Weights called Adaptive MDW (A-MDW) and making it more adaptive such that the method continues generating weights until the SO solver optimizing the related weighted sum problems is no longer efficient.

3. We introduced Partitioned Pareto Local Search (P-PLS), which aims at speeding-up PLS-VND through the partitioning of the set of solutions to explore, and a smart restriction of the PLS-VND neighborhood structure based on the presumption of global convexity on the addressed problem.

4. We suggested some modifications for any SO optimizer to improve its ability to find efficient solutions in MOCO problems, in particular memorizing the solutions generated during the optimization process.

Based on these specifications, we proposed a new version of Nested Monte Carlo Search (NMCS), called Aggregation-based NMCS (A-NMCS) better suited for MOCO than vanilla NMCS.

5. We presented a new component-wise meta-heuristic called 2-Phase Iterated Pareto Local Search with Decomposition (2PIPLS/D). During the first phase, A-MDW is used as initialization method and P-PLS builds a partition for speeding-up PLS-VND. At each iteration of the second phase, a set of solutions is first generated through the optimization of several well-dispersed data perturbed weightedsum problems, then PLS-VND is conducted from this set. 2PIPLS/D handles different mods and exploration strategies for PLS-VND, and embeds an -archive system which enable a good distribution in the objective space of the generated points and bounds the size of the approximation.

6. We implemented 2PIPLS/D for the MO symmetric Traveling Salesman Problem (MOTSP). 2PIPLS/D has been compared with state-of-the-art methods on large scale bi-objective and tri-objective TSP instances. Computational experiments show that 2PIPLS/D outperforms competitors on all tested instances, except for 5% of the instances where our own previous method PDA and 2PIPLS/D perform similarly. P-PLS provides surprisingly good performance as it reduces the number of explored solutions by 98% in average, compared to no partitioning. In the continuation of the work of Borges and Hansen [START_REF] Borges | A study of global convexity for a multiple objective travelling salesman problem[END_REF], we have experimentally confirmed the assumption of global convexity on MOTSP on a number of bi-objective and tri-objective instances. In the continuation of the work of [START_REF] Lust | Speed-up techniques for solving large-scale biobjective TSP[END_REF], we found that edges present in efficient solutions are of good quality compared to the other edges.

7. We implemented 2PIPLS/D for a new real-world problem related to the recent territorial reform of French regions, and called the French Regions Mapping Problem (MOFRMP), for which we proposed a MO formulation with 5 objectives. We have detected a number of departments of Metropolitan France more attracted by other regions than the current they belong to.

8. For both MOTSP and MOFRMP, 2PIPLS/D with the Monte Carlo Search-based method A-NMCS as SO solver is outperformed in most cases by 2PIPLS/D with a Local Search-based method.

Short-term and Middle-term perspectives

2PIPLS/D could be tested on other MOCO problems like MO asymmetric TSP, MO Minimum Spanning Tree, MO (Multidimensional) 0-1 Knapsack or MO (Quadratic) Assignment Problems. We are particularly interested in analyzing the behavior of the partitioning system of P-PLS on instances with negatively correlated objectives, making much more difficult the optimization of Local Search techniques, because it has an impact on the level of clustering of the solutions on these instances ( [Paquete andStützle, 2009a, Verel et al., 2011]).

Concerning PLS-VND in independent mod, it could be interesting to implement a MO tabu mechanism [Hansen, 1997] in order not to re-explore solutions already explored in previous runs.

Long-term perspectives: beyond PLS ?

Within the 2PIPLS/D framework, instead of employing PLS(-VND), it could be interesting to use an exact combinatorial optimization method. In fact, the partitioning method introduced in P-PLS is independent from the concept of PLS (it has indeed be designed as completely distinct from PLS). Therefore, the idea is to run a MO Branch and Bound or a MO Dynamic Programming algorithm (for example) from the reduced search space provided by the partitioning method. Note that the new archives we have proposed would be of high interest if a MO Dynamic Programming is used. For example, on MOTSP, one could use a MO version of the Branch Decomposition-based Dynamic Programming method of Cook and Seymour [START_REF] Cook | Tour merging via branch-decomposition[END_REF]. For MOKP, the method employed could be the MO Dynamic Program of Bazgan et al. [START_REF] Bazgan | Solving efficiently the 0-1 multi-objective knapsack problem[END_REF]. We believe that this search direction is promising given the large reduction of the search space provided by the partitioning system experienced on MOTSP.

Introduction

Les solutions de certains problèmes combinatoires peuvent être évaluées sur plusieurs objectifs, souvent contradictoires. Les conits entre les objectifs conduisent généralement à la diérence fondamentale suivante avec l'optimisation mono-objectif : deux solutions peuvent avoir des valeurs d'objectifs diérentes, représentant des compromis diérents des objectifs, et par conséquent, aucune n'est meilleure que l'autre. L'optimisation conjointe de plusieurs objectifs au sein d'un problème combinatoire a donné naissance au domaine de l'optimisation combinatoire multi-objectif (MOCO).

Un exemple classique d'objectifs conictuels concerne des problèmes tels que le problème du plus court chemin ou le problème de tournée de véhicule. Pour de tels problèmes, plusieurs objectifs peuvent être envisagés : le temps de parcours, l'empreinte écologique et naturellement le coût du trajet en fonction du moyen de transport choisi. Nous pouvons facilement constater qu'un certain nombre de ces objectifs sont généralement contradictoires, comme le temps de déplacement par rapport au coût du trajet ou à l'empreinte écologique. Cependant, à titre d'exemple, il peut être intéressant pour une entreprise soucieuse de l'environnement (ou même une personne) de choisir un itinéraire optimisant à la fois le temps de parcours et son empreinte écologique. Considérer un tel objectif écologique supplémentaire serait bénéque pour l'entreprise en promouvant son respect de l'environnement, et ce an attirer plus de clients. Concernant le problème d'ordonnancement rencontré par toute compagnie aérienne, outre la minimisation des coûts, nous pourrions considérer comme deuxième objectif le bien-être du personnel de bord, en tenant compte de leurs préférences de jours de travail. Bien que potentiellement en conit avec une minimisation des coûts, l'optimisation prenant en aussi compte le bien-être des employés pourrait potentiellement réduire le nombre de mouvements sociaux mais également améliorer l'image de marque de l'entreprise. Un autre exemple d'objectifs contradictoires apparaît dans un problème rencontré en nance, consistant à choisir un portefeuille parmi un ensemble de propositions d'investissement tout en optimisant deux objectifs contradictoires : la valeur attendue des rendements du portefeuille à maximiser, et le risque inhérent aux rendements du portefeuille à minimiser. Plus généralement, MOCO présente de nombreuses applications dans les domaines de la nance, du transport, de la médecine et des télécommunications, des problèmes de routage et des télécommunications et des problèmes de conception structurelle.

MOCO est une alternative intéressante pour les décideurs par rapport à l'optimisation combinatoire mono-objectif, car elle couvre diérents points de vue existants pour un même problème. En revanche, MOCO est confronté à des problèmes computationnels lorsque de multiples objectifs contradictoires sont considérés. D'ailleurs, la plupart des problèmes MO sont théoriquement diciles, dans le sens où leur version de décision est NP-dicile, même si la version mono-objectif sous-jacente peut être résolue en temps polynomial.

Les méthodes MOCO sont classées en méthodes exactes, méthodes d'approximation avec garantie de performance et (méta-)heuristique. En plus de cette classication, trois approches principales existent dans MOCO et chacune est plus ou moins exigeante pour le décideur. La première est l'approche interactive, qui interagit itérativement avec le décideur en lui demandant ses préférences à travers la sélection ou la classication des diérentes solutions suggérées par la méthode an de guider ecacement la recherche, et d'obtenir nalement une solution qui lui convient. La seconde est l'approche a priori qui vise à d'abord interroger le décideur sur ses préférences puis à guider le processus d'optimisation en fonction de ces préférences. À la n, la méthode produit un unique ou un petit ensemble de solutions. Ces deux types d'approches agrègent souvent les objectifs en un seul, de sorte que le problème peut alors être résolu comme problème mono-objectif. Une grande variété de fonctions d'agrégation existe dans la littérature, de la somme pondérée ou de l'agrégation Tchebychev pondérée, à des méthodes plus complexes capables de modéliser les préférences complexes du décideur comme l'intégrale de Choquet. Le troisième est l'approche a posteriori, pour laquelle les préférences du décideur ne sont pas connues a priori, c'est-à-dire non connues avant le processus d'optimisation. Cette approche est fortement reliée à la notion de dominance de Pareto : une solution domine une autre solution si elle est égale ou meilleure sur tous les objectifs et strictement meilleure sur au moins un objectif. En considérant cette notion de dominance de Pareto, le décideur ne serait pas intéressé par des solutions dominées et, par conséquent, le but d'une approche a posteriori est de trouver l'ensemble des solutions qui ne sont dominées par aucune autre solution, appelée ensemble des solutions ecaces (ou plus simplement ensemble ecace). Malgré le fait que dans la pratique nous recherchons un ensemble ecace réduit, c'est-àdire un ensemble ecace de sorte qu'une seule solution est mémorisée parmi toutes les solutions équivalentes, l'ensemble peut être extrêmement grand, en particulier dans le cas où plusieurs objectifs conictuels sont considérés. Ainsi, même pour des problèmes de taille modérée, il est généralement prohibitif d'identier un ensemble ecace réduit. En particulier, plusieurs problèmes MOCO sont intractables, en ce sens que le nombre de points peut être exponentiel dans la taille de l'instance. C'est pourquoi, en plus de la diculté inhérente des problèmes MO précédemment mentionnée, les méthodes exactes permettant de trouver un ensemble ecace réduit sont généralement utilisées pour des problèmes faciles, ou des problèmes plus diciles de petite taille. D'autre part, étant donné une tolérance prédénie dans la relation de dominance, les méthodes d'approximation avec garantie de performance seront capables de trouver une approximation de l'ensemble ecace dès le moment où les méthodes exactes deviennent impraticables. Ces méthodes d'approximation semblent être ecaces en théorie comme en pratique pour certains problèmes. Enn, les méta-heuristiques ne fournissent aucune garantie de performance sur la qualité de l'ensemble d'approximations trouvé, mais en raison de leur ecacité pratique, elles sont actuellement massivement utilisées pour optimiser des problèmes diciles de grandes tailles, là où les méthodes d'approximation avec garantie de performance sont dépassées. Les méta-heuristiques mono-objectif ont en fait été adaptées à MOCO, comme les algorithmes évolutionaires MO, la recherche locale MO, les métaheuristiques MO inspirées de la nature, et plus récemment la recherche Monte-Carlo MO. Une fois que l'ensemble ecace a été trouvé (ou une approximation), le décideur choisit la solution qui correspond au mieux à ses préférences en utilisant une méthode d'aide à la décision multi-crière.

Cadre de la thèse Nous espérons que ces deux archives et leurs versions adaptatives pourront être utiles pour de futures méta-heuristiques, en particulier celles qui utilisent PLS, la programmation dynamique MO ou les méthodes basées sur les zones de recherche.

Concernant les perspectives de la NDR*-Archive, on pourrait trier les ls d'un n÷ud interne en utilisant leur clé de Hilbert (ou n'importe quelle clé provenant d'une courbe de remplissage, comme la courbe de Peano). Comme l'AVL-Archive qui utilise des propriétés spéciques au cas bi-objectif, il pourrait être intéressant d'utiliser les propriétés spéciques des espaces de dimensions xes de tailles 3, 4 ou 5. D'autres recherches semblent nécessaires pour améliorer l'ecacité de NDR*-Archive dans le cas où 5 objectifs ou plus sont considérés.

Une amélioration possible de l'AVL-Archive est d'utiliser les mouvements de type splay pour réorganiser l'arborescence, an que le n÷ud en cache soit placé à la racine de l'arbre. Cependant, cette modication pourrait rendre l'arbre déséquilibré. Concernant les perspectives, il pourrait être intéressant de mettre en place des structures de voisinage (dans PLS-VND) avec une plus grande taille que le 3-exchange, ou mieux encore, de proposer des mouvements de type variable k-exchange comme dans Lin-Kernighan. Cependant, nous avons deux principales limitations à propos de cette perspective. Tout d'abord, les techniques qui ont rendu les méthodes de recherche locale si puissantes pour le TSP, comme les don't look bits ou les listes de candidats, ne sont pas aussi ecaces pour le MOTSP. Deuxièmement, il semble que l'étape de perturbation globale de 2PIPLS/D soit susamment ecace pour compenser une petite taille de structure de voisinage de PLS-VND.

Une deuxième perspective est l'application de 2PIPLS/D sur des instances plus importantes, à la fois en termes de tailles et de nombre d'objectifs. Selon nous, la principale limitation concernant cette proposition est que 2PIPLS/D, comme toute méthode basée sur le framework de la PLS à deux phases, sont très sensibles à la méthode d'optimisation mono-objectif utilisée pour (ré)démarrer la PLS. En eet, les méthodes d'optimisation mono-objectif basées sur l'algorithme de Lin-Kernighan semblent être la meilleure option que nous ayons actuellement, mais ne sont pas si ecaces sur les instances dans lesquelles il n'y a pas d'inégalité triangulaire. Par conséquent, des dicultés sont attendons pour ce type de méthodes sur des instances aléatoires, bi-objectif ou tri-objectif de taille 1000, ou sur des instances de grandes tailles considérant 4 objectifs ou plus. Perspectives à court et moyen termes 2PIPLS/D pourrait être testé sur d'autres problèmes MOCO. Le comportement du système de partitionnement de P-PLS sur des instances avec des objectifs corrélés négativement nous intéresse particulièrement. Car cela rend beaucoup plus dicile l'optimisation par les diérentes méthodes de recherche locale dû à l'impact sur le niveau de clusterisation des solutions de telles instances.

En ce qui concerne PLS-VND en mode indépendant, il pourrait être intéressant de mettre en place un mécanisme tabu an de ne pas réexaminer les solutions déjà explorées lors des runs précédents.

Perspectives à long terme The first one generalizes and improves an existing method generating an initial set of solutions. The second one reduces efficiently the search space and accelerates PLS without notable impact on the quality of the generated approximation. We also introduce two new data structures for dynamically managing a set of incomparable solutions. The first one is specialized for the bi-objective case, while the second one is general. 2PIPLS/D is applied to the bi-objective and tri-objective Traveling Salesman Problem and outperforms its competitors on tested instances. Then, 2PIPLS/D is instantiated on a new five-objective problem related to the recent territorial reform of French regions which resulted in the reassignment of departments to new larger regions.

  := {λ = (λ 1 , ..., λ p ) : λ ∈ Λ 0 , λ j = d D , d ∈ {0, ..., D}, j = 1, ..., p} such that min λ a ,λ b ∈Λ 0 : λ a =λ b

Figure 2 . 4 -

 24 Figure 2.4 -An example of ILS run minimizing a fitness function F : X → R on the feasible set X.

Figure 2 . 7 -

 27 Figure 2.7 -An example of a 2-exchange move applied on a tour.

Figure 2 .

 2 Figure 2.11 illustrates a ND-Tree in the bi-objective case.

•

  Figure 3.2 -The Add procedure of an AVL-Archive with a candidate solution x ∈ X.

  LeftPruning procedure, depicted with a diagram in Figure3.4 and in pseudo-code by Algorithm 13. Figure 3.3 illustrates an example of execution of the LeftPruning procedure on a subtree of an AVL-Archive. The LeftPruning procedure is recursive and takes as input parameters a calling node η l ∈ Θ(l(η)), the deepest node of the subtree to re-balance uη ∈ Θ(l(η)) and the candidate solution x.

Figure 3 . 3 -

 33 Figure 3.3 -Example of execution of the LeftPruning procedure. The node η is s.t.x(η) has just been replaced by a candidate solution x ∈ X s.t. f (x) = (80, 80), and Θ(l(η)) and Θ(r(η)) have just been disconnected from η. Then, LeftPruning procedure is started from l(η) and follows a unique top-down path (indicated in bold edges) until reaching a leaf node. The procedure finally returns the node uη which is the deepest node to re-balance. The symmetrical process is performed in Θ(r(η)) via the RightPruning procedure but is not detailed.

  child then replace η l by l(η l ) as child of p(η l ) delete η l and Θ(r(η l )) return LeftPruning(l(η l ), uη, x) else delete Θ(η l ) return uη else // x does not dominate both x(η l ) & Θ(l(η l )) if η l has a right child then return LeftPruning(r(η l ), uη, x) else return uη It returns the deepest node to re-balance. It uses the result pointed out by Proposition 3.1.3 to remove efficiently from Θ(l(η)) all nodes dominated by x.

  Next, the four different rotations introduced in [Adelson-Velskii, 1962] are detailed. There are four different types of rotations: simple left, simple right, double left-right and double right-left. Definition 3.1.2. Let η be a node and ρ its right child. A simple left rotation rooted at η consists in ascending ρ such that η becomes the left child of ρ, and the left child of ρ becomes the right child of η. The new root of the subtree affected by the rotation is ρ.

Figure 3 .

 3 Figure 3.5 illustrates a simple left rotation. Definition 3.1.3. Let η be a node and λ its left child. A simple right rotation rooted at η consists in ascending λ such that η becomes the right child of λ, and the right child of λ becomes the left child of η. The new root of the subtree affected by the rotation is λ.

Figure 3

 3 Figure 3.5 -Illustration of a simple left rotation.

Figure 3 .

 3 Figure 3.6 illustrates a double left-right rotation. Definition 3.1.5. Let η be a node, λ its left child and µ the right child of λ. A double right-left rotation rooted at η is a two-step rotation. First, it consists in applying a left rotation rooted at λ, then a right rotation rooted at η. The new root of the subtree affected by the rotation is µ.

  The general situation faced by an AVL-Archive when a node is unbalanced, is introduced by the following proposition and illustrated by Figure3.7. Proposition 3.1.4. Let Θ be a subtree and η its root, λ = l(η) and ρ = r(η). The node η is unbalanced s.t. β(η) = ∆ where |∆| ≥ 2. Let us assume that the rest of Θ is balanced: |β(λ)| ≤ 1, |β(ρ)| ≤ 1 and the subtrees Lλ = Θ(l(λ)), Rλ = Θ(r(λ)), Lρ = Θ(l(ρ)) and Rρ = Θ(r(ρ)) are balanced. 1. If ∆ ≥ 2 and β(ρ) ∈ {0, 1}, then after a simple left rotation rooted at η, the root of Θ is ρ, |β(ρ)| ≤ 1, β(η) < ∆ and the height of Θ is unchanged or has strictly decreased. 2. If ∆ ≤ -2 and β(λ) ∈ {-1, 0}, then after a simple right rotation rooted at η, the root of Θ is λ, |β(λ)| ≤ 1, β(η) > ∆ and the height of Θ is unchanged or has strictly decreased. 3. Let µ be the root of Lρ. If ∆ ≥ 2 and β(ρ) = -1, then after a double left-right rotation rooted at η, the root of Θ is µ, |β(µ)| ≤ 1, |β(ρ)| ≤ 1, β(η) < ∆, and the height of Θ has strictly decreased.

  An unbalanced subtree rooted at η. Subtrees Θ(λ), Lµ, Rµ and Rρ are balanced. A right rotation rooted at ρ is performed.

  The temporary tree. A left rotation rooted at η is performed.µ β(µ) ∈ {0, 1} η β(η) ∈{∆-3,∆-2} ρ β(ρ)The final balanced tree rooted at µ.

Figure 3 Figure 3

 33 Figure 3.6 -Illustration of a double left-right rotation.

Algorithme 15 :

 15 ReBalanceAfterInsert Input : parent η of newly inserted node Output : ∅ rotated ←false repeat ( , rotated) ←Rotation(η) η ← p( ) until η = none or β(η) = 0 or rotated;

Algorithme 17 :

 17 ReBalanceAfterDelete Input : calling node η Output : root of the subtree repeat ←RotationChain(η) η ← p( ) until η = none; return η

Figure 3 .

 3 Figure 3.8 illustrates an example of the insertion of a candidate solution into an AVL-Archive. Proposition 3.1.6. The complexity in time of the Add procedure is in O(log 2 2 s), where s is the number of nodes in the AVL-Archive.

  The subtree rooted at (175, 25) is unbalanced ⇒ a double left-right rotation is performed. The subtree rooted at (110, 38) is unbalanced ⇒ a simple left rotation is performed.(d) The final balanced tree.

Figure 3

 3 Figure 3.8 -Example of insertion of a candidate x ∈ X s.t. f (x) = (110, 38) into an AVL-Archive.

  z

  View in the objective space of the archive. Points are indicated with circles and local ideals are indicated with squares. An internal point and its associated local ideal are linked by a dashed line.

Figure 3

 3 Figure 3.9 -Example of a SAAVLA

Figure 3 .

 3 Figure 3.9 illustrates an example of a SAAVLA.

•

  Figure3.12 -The Restructure tree procedure of NDR*-Archive called from a node η.

  and both R and R are inserted into Q.

Figure 3 .

 3 Figure 3.13 -Example of insertion of a new candidate solution x in a NDR * -Archive in the bi-objective case.We assume that x has already been checked for non dominance; and that internal and leaf nodes can contain at most two elements and at least one element.

  The tree and the rejection path related to a candidate dominated by node b 2 . The resulting ajusted tree in order to have the path R -A -B -b 2 in first position. The resulting ajusted tree in order to have the path R -A -C -c 1 in first position.

Figure 3 .

 3 Figure 3.14 -Illustration of the self-adjusting feature of SANDRA with an example of a rejection of a candidate (first row) followed by an acceptation of another candidate (second row). The numbers close to the nodes indicate the exploration order of the nodes.

Figure 3 .

 3 Figure 3.15 -Influence of the parameters C child max (left), C solution max (right) and R min on the computational time of NDR * -Archive with I1 + L1 splits (p = 4, N dom = 30000, φ dom = 10, ε = 15%).

Figure 3

 3 Figure 3.16 -Evolution of the running time of different combinations of splits in function of the number of objectives.

Figure 3

 3 Figure 3.17 -Computational time comparison between the different archives in function of the proportion of dominated points φ dom for p = 2, 3, 4, 5 (N nd = 10000, ε = 25%).

  Archive -rejected candidates NDR*-Archive -accepted candidates ND-Tree -rejected candidates ND-Tree -accepted candidates (b) Evolution of the number of dominance comparisons in NDR*-Archive and ND-Tree.

Figure 3 .

 3 Figure 3.18 -Evolution of the proportion of accepted candidates (a) and number of dominance comparisons in NDR * -Archive and ND-Tree (b) in function of the number of objectives (N nd = 10000, φ dom = 10, ε = 5%).

Figure 3 .

 3 Figure 3.19 -Evolution of the computational time of NDR * -Archive and ND-Tree for PLS in function of the number of objectives ("la" stands for local archive).

Figure 3 .

 3 Figure 3.19 summarizes the results by comparing the computational time of SANDRA, and NDR * -archive and ND-Tree with local archive in function of p.

  Based on these suggestions, Aggregation-based NMCS (A-NMCS) is a new version of NMCS especially designed for MOCO. Second, a more adaptive and generalized version of MDW called Adaptive MDW (A-MDW) is presented. Third, we introduce Partitioned Pareto Local Search (P-PLS) which aims at speeding-up PLS-VND. Then, we propose a new MO meta-heuristic called 2-Phase Iterated Pareto Local Search with Decomposition (2PIPLS/D). Finally, a new system based on the -archive concept is presented.

  e) The resulting subdivided simplex with the new simplices.

Figure 4 . 2 -

 42 Figure 4.2 -Illustration of the subdivision of a simplex with a base b = 2 and p = 3.

Figure 4 . 4 -Figure 4

 444 Figure 4.4 -View in the weight space of weights generated by successive iterations of an iterative simplex subdivision (p = 3, ε = 0).

Figure 4 . 6 -

 46 Figure 4.6 -The A-MDW procedure.

  Figure 4.8 illustrates an example of widening phases centered on a subarchive.Algorithme 29 : A-MDW Input : SO optimizer SO-Optimizer, min. acceptance rate threshold α, real ε Output : list of generated weights Lλ all , global archive X all // Initialization: η total , η accept ← 0 N accept : R p -→ N // maps to each weight (corresponding to a weighted sum pb. optimized), the number of solutions accepted in the archive Lλ all ← ∅ X all ← ∅ LΛ ← {Λ ε } while true do Lλ new ← ∅ // Next weights: foreach Λ = (λ 1 , ..., λ p ) ∈ LΛ do for j ← 1, ..., p do if λ j / ∈ Lλ all then Lλ all ← Lλ all ∪ {λ j } Lλ new ← Lλ new ∪ {λ j } // Optimize weighted sum problems: foreach λ ∈ Lλ new do // Optimize λf (•):

Figure 4 . 7 -

 47 Figure 4.7 -View in a tri-objective space of the partitioning of an archive into 32 sub-archives (tri-objective TSP instance).

Figure 4

 4 Figure 4.8 -Illustration of two widening phases related to a sub-archive (tri-objective TSP instance). The figure distinguishes the sub-archive of interest (in red), its source (in blue) and all the other sub-archives (in gray).

Figure 4

 4 Figure 4.10 -The 2PIPLS/D procedure.

Algorithme 38 :

 38 Figure 4.11 shows the main steps of a single iteration of 2PIPLS/D, and in particular illustrates the difference between the two PLS-VND mods.

  c) Pareto Local Search step (first option): Set of starting solutions of PLS-VND run in independent mod. Local Search step (second option): Set of starting solutions of PLS-VND run in dependent mod.

Figure 4 .

 4 Figure 4.11 -Main steps of a 2PIPLS/D iteration. Newly generated solutions are represented by bullets while the other solutions are represented by squares. Starting solutions of PLS-VND are circled.

Figure 4 .

 4 Figure 4.12 illustrates an hyper-grid of an -archive in a bi-objective space.

  Distribution of ranks of ef f icient edges. Distribution of ranks of all edges.

Figure 5

 5 Figure 5.1 -Distribution of ranks of efficient edges vs. all edges, in function of the number of objectives and the size of instances.

Figure 5 . 2 -

 52 Figure 5.2 -Representation in the MO cost space of the edges composing (potentially) efficient solutions (represented by squares) and the other edges (represented by bullets) in bi-objective instances of size 100.

Figure 5

 5 Figure 5.3 -Average distance between (potentially) efficient solutions in function of the distances between their images (points) in the objective space.

Figure 5

 5 Figure 5.4 -Comparison in terms of normalized I - H (median values, to be minimized) between 2PIPLS/D with Vanilla C-LK and 2PIPLS/D with Improved C-LK.

Figure 5

 5 Figure 5.5 -Comparison in terms of normalized I - H (median values, to be minimized) between 2PIPLS/D with NMCS and 2PIPLS/D with A-NMCS.

Figure 5 Figure 5

 55 Figure 5.6 -Influence of the minimum acceptance rate threshold α of A-MDW on 2PIPLS/D performance in terms of normalized I - H (median values, to be minimized) in function of the running time. Curves start at the end of the first phase (A-MDW+P-PLS) of 2PIPLS/D.

Figure 5

 5 Figure 5.8 -Influence of the maximum initial size σ of part of P-PLS on 2PIPLS/D performance in terms of normalized I - H (median values, to be minimized) in function of the running time. Curves start at the end of the first phase (A-MDW+P-PLS) of 2PIPLS/D.

Figure 5

 5 Figure 5.9 -Influence of the PLS-VND maximum neighborhood structure size k on 2PIPLS/D performance in terms of normalized I - H (median values, to be minimized) in function of the running time. Curves start at the end of the first phase (A-MDW+P-PLS) of 2PIPLS/D.

Figure 5 Figure 5

 55 Figure 5.10 -Comparison in terms of normalized I - H (median values, to be minimized) between 2PIPLS/D with dependent PLS-VND and 2PIPLS/D with independent PLS-VND.

Figures 5 .

 5 Figures 5.12 to 5.19 detail the I , I - H , and I R2 performance of the approximation sets produced by 2PIPLS/D (with C-LK), PDA, MoMad and PD-TPLS.

Figure 5 Figure 5 Figure 5 Figure 5

 5555 Figure 5.12 -I (left), I - H (middle) and I R2 (right) performance comparison between 2PIPLS/D (with C-LK optimizer), PDA, and MoMad on bi-objective instances of size 100.

Figure 5

 5 Figure 5.16 -I (left), I - H (middle) and I R2 (right) performance comparison between 2PIPLS/D (with C-LK optimizer), PDA, MoMad and PD-TPLS on tri-objective instances of size 50.

Figure 5

 5 Figure 5.17 -I (left), I - H (middle) and I R2 (right) performance comparison between 2PIPLS/D (with C-LK optimizer), PDA, MoMad and PD-TPLS on tri-objective instances of size 100.

Figure 5

 5 Figure 5.18 -I (left), I - H (middle) and I R2 (right) performance comparison between 2PIPLS/D (with C-LK optimizer), PDA, MoMad and PD-TPLS on tri-objective instances of size 300.

Figure 5

 5 Figure 5.19 -I (left), I - H (middle) and I R2 (right) performance comparison between 2PIPLS/D (with C-LK optimizer), PDA, MoMad and PD-TPLS on tri-objective instances of size 500.

Figure 5

 5 Figure 5.20 -Comparison of number of examined solutions between 2PIPLS/D (with C-LK) and its competitors.

  7 published in French by France Stratégie and initiated by A. Amabile (France Stratégie), C. Bernard (France Stratégie) and A. Épaulard (France Stratégie and Laboratoire d'Économie de Dauphine) and implemented by T. Cazenave.

  r∈R d∈Dr(x) d ∈Dr(x) : d >d com d,d |D r (x)| (|D r (x)| -1) /2 9 based on the Insee 2011 database on demography 10 based on the Insee 2010 database on commuting where com d,d is the intensity indicator value of commuting between departments d and d .

  Figure 6.2 -Average size of intersection (in terms of % of departments in D \ R) between solutions in the same cluster in function of the cluster size, where a cluster is a set of solutions neighbors in the objective space.

  Comparison between 2PIPLS/D with ILS (and k = 2) vs. 2PIPLS/D with A-NMCS (and k = 2). Comparison between 2PIPLS/D with data perturbation (δ = 5% and k = 1, 2) vs. 2PIPLS/D without data perturbation (δ = 0% and k = 1, 2).

Figure 6

 6 Figure 6.3 -Influence of the SO solver used and the presence of data perturbation on 2PIPLS/D performance in terms of I - H (median values, to be minimized) in function of the running time. Curves start at the end of the first phase (A-MDW+P-PLS) of 2PIPLS/D.

  Comparison between different versions of 2PIPLS/D (with ILS and k = 2) with alternative values of maximum initial size of a part σ of P-PLS. Comparison between different versions of 2PIPLS/D (with ILS) with alternative values of PLS-VND maximum neighborhood structure size k. Comparison between 2PIPLS/D with dependent PLS-VND vs. 2PIPLS/D with independent PLS-VND.

Figure 6 . 4 -

 64 Figure 6.4 -Influence of the maximum initial size of a part σ of P-PLS, the PLS-VND maximum neighborhood structure size k, and the (In)dependence of PLS-VND on 2PIPLS/D performance in terms of I - H (median values, to be minimized) in function of the running time. Curves start at the end of the first phase (A-MDW+P-PLS) of 2PIPLS/D.

Figure 6

 6 Figure 6.5 -One of the (potentially) efficient maps the least distant from the current map.

4

  Nouvelles méthodes d'optimisation : Résumé Nous avons proposé dans ce chapitre un certain nombre d'améliorations de méthodes existantes et de nouvelles méthodes d'optimisation pour s'attaquer plus ecacement aux problèmes MOCO. Nous avons tout d'abord suggéré trois modications des méthodes d'optimisation monoobjectif pour améliorer leur capacité à trouver des solutions ecaces dans les problèmes MOCO : démarrer/guider systématiquement la recherche à partir d'une solution déjà trouvée, mémoriser les solutions générées pendant le processus d'optimisation et activer la perturbation des données. Sur la base de ces spécications, nous avons proposé une nouvelle version de Nested Monte-Carlo Search (NMCS), appelée A-NMCS, mieux adaptée au MOCO que la version originale de NMCS.Deuxièmement, nous avons présenté une nouvelle méthode généralisant l'algorithme Maximally Dispersed set of Weights, appelé A-MDW et le rendant plus adaptatif de sorte que la méthode continue de générer des poids jusqu'à ce que la méthode optimisant les problèmes de somme pondérée associés ne soit plus ecace.Troisièmement, nous avons introduit la recherche locale Pareto partitionnée (P-PLS), qui vise à accélérer la recherche local Pareto avec descente variable (PLS-VND) à travers le partitionnement de l'ensemble de solutions à explorer, et une restriction intelligente de la structure de voisinage de PLS-VND basée sur la présomption de convexité globale sur le problème traité.Ensuite, nous avons proposé une nouvelle méta-heuristique MO appelée 2-Phase Iterated Pareto Local Search (2PIPLS/D) basée sur trois concepts importants : les métaheuristiques à 2 phases, les méthodes de décomposition et la recherche locale Pareto itérée, et combinant A-MDW, P-PLS, ainsi que les modications suggérées pour les méthodes d'optimisation mono-objectif.Enn, un nouveau système basé sur le concept d' -archive est présenté, permettant de limiter la taille d'une archive tout en garantissant une bonne répartition des points dans l'espace objectif. 5 Application de 2PIPLS/D au MOTSP : Résumé Dans ce chapitre, nous avons d'abord proposé une implémentation des diérents composants algorithmiques de 2PIPLS/D, en particulier nous avons proposé d'utiliser le Chained Lin Kernighan (C-LK) et l'A-NMCS comme méthodes d'optimisation mono-objectif, et suggéré une implémentation de la structure de restriction de voisinage de P-PLS. Ensuite, nous avons présenté une preuve empirique de convexité globale sur le MOTSP an de légitimer l'utilisation du système de partitionnement de P-PLS. Nous avons constaté que les solutions (potentiellement) ecaces sont eectivement concentrées dans l'espace de décision et que les solutions (potentiellement) ecaces dans l'espace des objectif ont tendance à être également voisines dans l'espace de décision. Après une analyse de sensibilité de 2PIPLS/D sur ses paramètres, nous avons classé les diérents paramètres en fonction de leur inuence sur la performance de nôtre méthode. Nous avons constaté que 2PIPLS/D est sensible au nombre de problèmes de somme pondérée optimisés lors de l'initialisation avec A-MDW, mais aussi à la taille maximale autorisée d'une partie (de la partition générée) lors de l'initialisation de P-PLS. En particulier, nous avons noté que la P-PLS réduit drastiquement le nombre de solutions examinées par PLS-VND (-98% en moyenne sur les instances testées) grâce à son système de partitionnement. En outre, la mémorisation des solutions au cours de l'exécution d'une méthode mono-objectif semble être très ecace, à la fois pour C-LK et A-NMCS. D'un autre côté, 2PIPLS/D ne semble pas particulièrement sensible à la perturbation des données, à la taille maximale de la structure du voisinage et aux diérentes stratégies et modes d'exploration utilisés par PLS-VND. Enn, nous avons comparé 2 versions de 2PIPLS/D (soit avec C-LK amélioré ou bien avec A-NMCS) avec les meilleures méthodes actuelles sur un grand nombre d'instances bi-objectif et tri-objectif. 2PIPLS/D (avec C-LK) obtient de bons résultats et trouve l'ensemble non-dominé de 7 instances bi-objectif de taille 100 en 20 runs, de sorte que 2PIPLS/D est, à notre connaissance, la première méta-heuristique capable de trouver un ensemble non-dominé d'instances MOTSP d'une telle taille. 2PIPLS/D (avec C-LK) surpasse MoMad et PD-TPLS sur toutes les instances testées ; 2PIPLS/D surpasse également PDA sur 95% des instances testées et a des performances équivalentes pour les 5% d'instances restantes.Enn, 2PIPLS/D avec C-LK surpasse dans une grande majorité des cas 2PIPLS/D avec A-NMCS, ce qui renforce le fait que les performances 2PIPLS/D dépendent fortement de l'ecacité de la méthode mono-objectif utilisée.

  AbstractMany Combinatorial Optimization problems consider several, often conflicting, objectives. This thesis deals with Local Search, data structures and Monte Carlo Search methods for finding the set of efficient solutions of such problems, which is the set of all best possible trade-offs given all the objectives. We propose a new approximation method called 2-Phase Iterated Pareto Local Search based on Decomposition (2PIPLS/D) combining the notions of Pareto Local Search (PLS) and Decomposition. PLS is a local search descent adapted to Multi-Objective spaces, and Decomposition consists in the subdivision of the Multi-Objective problem into a number of Single-Objective problems. Two Single-Objective methods are considered: Iterated Local Search and Nested Monte Carlo Search. Two main components are embedded within the 2PIPLS/D framework.

  solution in the archive, the candidate is rejected; otherwise the candidate is accepted: all solutions dominated by the candidate are removed from the archive, then the candidate is inserted. Instead of the usual dominance relation ≤, one can use the dominance given a predefined . Different algorithms with different theoretical guarantee and practical efficiency exist for processing the Add procedure (see Section 2.4 for existing algorithms and Chapter 3 for new algorithms).

	return true
	else
	return false
	dominated by any

  Talbi et al. PLS enables to protect much more solutions. Therefore, if we add the option to Talbi et al. PLS not to explore dominated solutions stored in the temporary set, as we will propose later in Section 4.3, then we can consider that Talbi et al. PLS is more general than Paquete et al. PLS. For all these reasons, and to have a unique coherent framework, we consider only the Talbi et al. PLS, consisting in selecting all solutions from X at each iteration. Input : neighborhood structure N • , boolean first-dominating, set of solutions to explore X, global archive X all Output : archive of new solutions X new

	Algorithme 4 : PLS-iteration [vanilla]

  Algorithme 5 : PLS-iteration [with local archive] Input : neighborhood structure N • , boolean first-dominating, set of solutions to explore X, global archive X all Output : archive of new solutions X new

Algorithme 11 : NMCS Input : level, starting state s start Output : best sequence of actions seq best , best solution x best

  The method is recursive and takes as input parameters a level of recursion level and a starting state s start (initially s 0 ). It returns the best sequence of actions found so far seq best and the related solution x best .

		x			x				x
	x	x	x		x	x			x	x
	x	x
			x	x	x	x	x		x
		x
	x				x	x			x	x	x
				x			x	x
	x	x 2				x			x	x	x	x
		seq 2			x 4
	x 1			x	seq 4	x 5	x	x	x 7	x 5
	seq 1		x 3		seq 5	x 3		seq 7	seq 5	x	x
			seq 3			seq 3	x 6 seq 6	x 8 seq 8	x 9
									seq 9
	(a) F (x 3 ) is the best	(b) F (x 5 ) is the best		(c) F (x 5 ) is still the best
	⇒ set seq 3 as best seq.	⇒ set seq 5 as best seq.	⇒ keep seq 5 as best seq.
	Figure 2.6 -Illustration of three iterations of a NMCS of level 1. Filled nodes and bold edges correspond
	to the part of the best sequence already performed. The remaining part of the currently memorized best
	sequence is indicated with double red strokes.
	NMCS is detailed by Algorithm 11.
	s ← s start
	if level = 0 then
	return RandomSimulation(s)
	i ← 1
	repeat
	foreach a ∈ Actions(s) do
	s ←PerformAction(a, s)
	(seq, x) ←NMCS(level -1, s)
	s ←UnperformAction(a, s)
	if F (x) is better than F (x best ) then
	x best ← x
	seq best ← seq
	a best ←seq best [i++]
	s ←PerformAction(a best , s)
	until IsTerminal(s);
	return (seq best , x best )

  Example of a 3-opt move applied on a tour.In general, a k-opt (cf. Figure2.8) works as follows. Let x ∈ X be the current tour. At each iteration of a k-opt, all cities are successively considered as starting cities for k-exchange moves. From a starting city η 1 , a k-opt move attempts to find two sets of edges E out = {e 1 , e 2 , ..., e k } (out-edges) and E in = {f 1 , f 2 , ..., f k } (in-edges) such that, if the edges of E out are deleted from x and replaced by the edges of E in , the result is a better tour. E out and E in are initially empty and iteratively constructed. At each step i, a pair of edges (e i , f i ) are added to E out and E in respectively, such that e i = (η 2i-1 , η 2i

  Given Proposition 3.1.4 and as illustrated by Figures 3.5 and 3.6, applying a rotation on η pushes down the imbalance by descending η and strictly improving its absolute balance factor but kept unbalanced if |β(η))| > 2, and such that the rest of the nodes are still balanced. From this observation, we propose the concept of rotation chain, which consists in performing successive rotations on the same node η until |β(η)| ≤ 1.

Algorithme 16 : RotationChain Input : calling node η Output : new root of the subtree ( , •) ←Rotation(η) while |β(η)| ≥ 2 do Rotation(η) return

  Algorithme 21 : Prune Input : calling node η, candidate solution x, list of nodes to reinsert N in , list of solutions to reinsert X in

	Output : boolean
	if x nadir(η) then
	return false
	if x ideal(η) then
	return true
	if η is internal then

Table 3

 3

	φ dom	Archive	Number of comparisons	Time (ms)	φ dom	Archive	Number of comparisons	Time (ms)
	0	NDR*-Archive 169 ND-Tree 145 -14%	50 65	+30%	0	NDR*-Archive 295 +23% ND-Tree 239	472 554	+18%
	1	NDR*-Archive 143 ND-Tree 131	86 109	+27%	1	NDR*-Archive 227 ND-Tree 214	737 928	+26%
	10	NDR*-Archive 127 ND-Tree 141 +11%	461 659	+43%	10	NDR*-Archive 190 ND-Tree 223 +18%	3,649 5,833	+60%
	100	NDR*-Archive 129 ND-Tree 173 +34%	4,288 8,087	+89%	100	NDR*-Archive 196 ND-Tree 262 +33%	41,979 78,857	+88%
	1000	NDR*-Archive 112 ND-Tree 192 +72% 104,332 +146% 42,338	1000	NDR*-Archive ND-Tree	25 24	434,130 908,101 +109%
		(a) ε = 5%, N nd = 10000			(b) ε = 5%, N nd = 50000
	φ dom	Archive	Number of comparisons	Time (ms)	φ dom	Archive	Number of comparisons	Time (ms)
	0	NDR*-Archive 181 +19% ND-Tree 152	62 72	+15%	0	NDR*-Archive 293 +20% ND-Tree 244	511 575	+12%
	1	NDR*-Archive 126 ND-Tree 123	79 102	+30%	1	NDR*-Archive 188 ND-Tree 177	639 772	+21%
	10	NDR*-Archive 82 ND-Tree 103 +26%	231 397	+71%	10	NDR*-Archive 100 ND-Tree 124 +24%	1,599 2,603	+63%
	100	NDR*-Archive 79 ND-Tree 114 +45%	1,908 4,071	+113%	100	NDR*-Archive 89 ND-Tree 127 +42%	11,585 24,626	+113%
	1000	NDR*-Archive 84 ND-Tree 127 +51% 52,605 +135% 22,351	1000	NDR*-Archive ND-Tree	9 11 +27% 329,107 +122% 148,460

.3 -Performance of archives for p = 3. (c) ε = 25%, N nd = 10000 (d) ε = 25%, N nd = 50000

Table 3

 3

	φ dom	Archive	Number of comparisons		Time (s)	φ dom	Archive	Number of comparisons	Time (s)
	0	NDR*-Archive 207 +10% 0.07 ND-Tree 188 0.08 +29%	0	NDR*-Archive 436 +30% 0.73 ND-Tree 335 0.83 +14%
	1	NDR*-Archive 180 ND-Tree 166	0.12 0.14 +23%	1	NDR*-Archive 352 +17% 1.23 ND-Tree 302 1.45 +18%
	10	NDR*-Archive 212 +20% 0.80 ND-Tree 177 0.94 +18%	10	NDR*-Archive 416 +21% 9.10 ND-Tree 344 11.47 +26%
	100	NDR*-Archive 305 +26% ND-Tree 242	12 15	+20%	100	NDR*-Archive 588 +26% 169 ND-Tree 467 204 +17%
	1000	NDR*-Archive 290 ND-Tree 290	153 220 +43%	1000	NDR*-Archive 46 ND-Tree 49	200 275 +37%
		(a) ε = 5%, N nd = 10000				(b) ε = 5%, N nd = 50000
	φ dom	Archive	Number of comparisons		Time (s)	φ dom	Archive	Number of comparisons	Time (s)
	0	NDR*-Archive 240 +12% 0.07 ND-Tree 214 0.09 +29%	0	NDR*-Archive 469 +28% 0.74 ND-Tree 367 0.86 +17%
	1	NDR*-Archive 201 ND-Tree 205	0.11 0.16 +40%	1	NDR*-Archive 351 +12% ND-Tree 313	1.1 1.4	+27%
	10	NDR*-Archive 183 ND-Tree 222 +21% 0.95 +64% 0.58	10	NDR*-Archive 242 ND-Tree 288 +19%	5 8	+67%
	100	NDR*-Archive 255 ND-Tree 305 +20%	9 17	+84%	100	NDR*-Archive 306 ND-Tree 357 +17%	70 123 +77%
	1000	NDR*-Archive 319 ND-Tree 367 +15% 271 +81% 149	1000	NDR*-Archive 38 ND-Tree 36	1,245 1,887 +52%

.4 -Performance of archives for p = 4.

(c) ε = 25%, N nd = 10000

Table 3

 3

	n	|X all | φ dom	Archive	Local archive	Number of comparisons	PLS time (s)
				SANDRA	-	14.9		18
				SANDRA	List-MF	27.3	+84%	30	+67%
	50	93590	677	NDR * -Archive NDR * -Archive	List-MF -	34.4 73.9	+132% +397%	32 35	+77% +93%
				ND-Tree	List-MF	53.1	+257%	43	+140%
				ND-Tree	-	168.1 +1,031%	84	+366%
				SANDRA	-	13.9		136
				SANDRA	List-MF	26.7	+92%	227	+67%
	75 374393 1303	NDR * -Archive NDR * -Archive	List-MF -	33.2 83.0	+139% +497%	241 293 +116% +77%
				ND-Tree	List-MF	56.5	+307%	335 +147%
				ND-Tree	-	236.7 +1,603% 809 +496%
				SANDRA	-	12.7		432
				SANDRA	List-MF	24.0	+89%	687	+59%
	100 817820 1955	NDR * -Archive NDR * -Archive	List-MF -	29.5 86.3	+132% +579%	726 973 +125% +68%
				ND-Tree	List-MF	52.1	+310%	1058 +145%
				ND-Tree	-	273.2 +2,049% 3297 +662%

.6 -Comparison between the different archive types on PLS with p = 2.

Table 3

 3

.7 -Comparison between the different archive types on PLS with p = 3.

Table 3 .

 3 8 -Comparison between the different archive types on PLS with p = 4.

	n	|X all | φ dom	Archive	Local archive	Number of comparisons	PLS time (s)
				SANDRA	-	60		9
				SANDRA	List-MF	67	+11%	12	+30%
		50369	193	NDR * -Archive NDR * -Archive	List-MF -	102 +69% 169 +180% 18 15	+64% +97%
				ND-Tree	List-MF	139 +130% 19 +112%
				ND-Tree	-	266 +342% 31 +239%
				SANDRA	-	64		60
				SANDRA	List-MF	73	+14%	79	+32%
		187127 311	NDR * -Archive ND-Tree	List-MF List-MF	119 +86% 105 +76% 168 +163% 138 +131%
				NDR * -Archive	-	222 +246% 143 +141%
				ND-Tree	-	370 +477% 251 +322%
				SANDRA	-	63		205
				SANDRA	List-MF	78	+20% 280 +36%
		446172 432	NDR * -Archive ND-Tree	List-MF List-MF	132 +89% 389 +90% 190 +162% 505 +146%
				NDR * -Archive	-	261 +253% 575 +180%
				ND-Tree	-	446 +488% 989 +383%
	n	|X all | φ dom	Archive	Local archive	Number of comparisons	PLS time (s)
				SANDRA	-	87	+26% 0.11
				SANDRA	List-MF	70		0.12
		1790	57	NDR * -Archive NDR * -Archive	List-MF -	87 138 +99% +25%	0.12 0.14 +22%
				ND-Tree	List-MF	111 +59%	0.18 +58%
				ND-Tree	-	198 +185% 0.26 +132%
				SANDRA	List-MF	188		36
				SANDRA	-	260 +38%	41	+14%
		81523	150	NDR * -Archive ND-Tree	List-MF List-MF	291 +55% 307 +64%	45 52	+26% +46%
				NDR * -Archive	-	547 +192%	76	+112%
				ND-Tree	-	596 +218%	95	+164%
				SANDRA	List-MF	236		505
				SANDRA	-	307 +30%	539
		480987 242	NDR * -Archive ND-Tree	List-MF List-MF	404 +71% 438 +85%	662 710	+31% +41%
				NDR * -Archive	-	774 +227% 1041 +106%
				ND-Tree	-	899 +280% 1360 +170%

* -Archive also with local archive. As usual, ND-Tree without local archive is outperformed by any other archive, and its version with local archive is approximately 150% slower than SANDRA. Concerning the number of comparisons, SANDRA with or without local archive outperforms the other archives.

For p = 5, SANDRA is still better than the other archives, but slightly better performance is obtained by using a local archive. The second best archive is still NDR * -Archive (with local archive). ND-Tree with local

Table 3

 3

	Normalized time	1.4 1.6 1.8 2 2.2 2.4 2.6		SANDRA SANDRA+la NDR*-A+la ND-Tree+la
		1.2
		1
		2	3	4	5
			Number of objectives

.9 -Comparison between the different archive types on PLS with p = 5.

  level, data perturbed weighted sum problem λf δ (•), starting state s start , best sequence of actions seq best , best solution x best Output : seq best , x best , global archive X all ←A-NMCS(level -1, λf δ (•), s, none, none) // Like in (vanilla) NMCS, the best seq. and the best sol. are not given to lower levels.

	Algorithme 27 : A-NMCS
	Input : s ← s start
	if level = 0 then
	(seq best , x best ) ←RandomSimulation(s)
	return (seq best , x best , {x best })
	X all ← ∅
	i ← 1
	repeat
	foreach a ∈ Actions(s) do
	s ←PerformAction(a, s)
	(seq, x, X) s ←UnperformAction(a, s)
	X

all ← AddAll(X, X all ) if λf δ (x) < λf δ (x best ) then x best ← x seq best ← seq a best ←seq best [i++]

s ←PerformAction(a best , s) until IsTerminal(s); return (seq best , x best , X all )

  UpdatePartition procedure. It takes as input parameters the set of all parts LP and the set of new solutions X new found by PLS-VND at current iteration.

	X(S)
	S∈LS(P )
	R(P ) ← BuildRestriction(X)
	return LP
	Algorithm 34 describes the

Add new solutions into appropriate archives of parts:

LP a ← ∅ foreach x ∈ X new do Add( x, X(P (x))) LP a ← LP a + P (x)

// Enlarge the set of sources of active parts with nearby parts: foreach P ∈ LP a do LS ext ← LP \ LS(P ) sort parts from LS ext in increasing order of their distance with P keep in LS ext only the 2 p-1 closest partition from P LS(P ) ← LS(P ) + LS ext // Widen accordingly the neighborhood restriction structure of active parts: foreach P ∈ LP a do X ←

Table 5

 5

.1 -MOTSP test benchmark.

Table 5

 5

	3	2.6	2.1	1.8	1.6

.4 -Impact of P-PLS partitioning on the average size of the candidate edge lists managed by PLS-VND and the number of solutions examined by PLS-VND.

(C-LK) 0.11 0.21 1.64 97 → 99.9

	Instance	Algorithm	I (%) (10 -5 ) (10 -1 ) I -H I R2	Coverage Nb. of exam. Time RAM X all (%) sol. (10 6 ) (s) (GB)	| Y nd |
		2PIPLS/D (C-LK) 0.12 0.23	1.91	97 → 100	7	11	< 3,288
		PDA	0.20	2.06	11.50	82 → 98	2	11	< 3,015
	kroAB100	2PIPLS/D (A-NMCS) 0.34	9.55	58.30	77 → 98	16	11	< 3,146	3,332
		MoMad	0.39 17.40 97.90	47 → 66	3	11	< 2,569
		AUGMECON2	0	0	0	100	-	72h	<	3,332
		2PIPLS/D (C-LK) 0.14 0.17	0.77	98 → 100	6	11	< 2,433
		PDA	0.18	1.60	11.40	84 → 98	2	11	< 2,263
	kroAC100	2PIPLS/D (A-NMCS) 0.32	5.01	24.30	78 → 99.5	13	11	< 2,288	2,458
		MoMad	0.40 14.30 68.50	52 → 71	2	11	< 2,062
		AUGMECON2	0	0	0	100	-	40h	<	2,458
		2PIPLS/D (C-LK) 0.09 0.14	0.75	97 → 100	5	10	< 2,314
		PDA	0.16	1.84	8.10	83 → 98	2	10	< 2,145
	kroAD100	2PIPLS/D (A-NMCS) 0.35	8.71	37.30	74 → 99.1	11	10	< 2,197	2,351
		MoMad	0.35 17.40 66.40	49 → 67	2	10	< 1,889
		AUGMECON2	0	0	0	100	-	26h	<	2,351
		2PIPLS/D (C-LK) 0.08 0.09	0.21	98 → 100	6	11	< 2,723
		PDA	0.14	1.55	5.58	83 → 98	2	11	< 2,538
	kroBC100	2PIPLS/D (A-NMCS) 0.21	5.78	14.80	83 → 99.7	15	11	< 2,625	2,752
		MoMad	0.28 12.20 46.50	47 → 68	2	11	< 2,205
		AUGMECON2	0	0	0	100	-	41h	<	2,752
		2PIPLS/D (C-LK) 0.11 0.18	1.48	97 → 100	6	11	< 2,632
		PDA	0.16	1.96	7.16	81 → 98	2	11	< 2,396
	kroBD100	2PIPLS/D (A-NMCS) 0.28 10.30 33.10	72 → 98	12	11	< 2,454	2,657
		MoMad	0.43 14.40 67.90	50 → 69	2	11	< 2,004
		AUGMECON2	0	0	0	100	-	35h	<	2,657
		2PIPLS/D (C-LK) 0.10 0.13	0.77	98 → 100	5	10	< 2,028
		PDA	0.19	1.69	6.91	86 → 99	1	10	< 1,907
	kroCD100	2PIPLS/D (A-NMCS) 0.40	8.13	35.20	78 → 99	10	10	< 1,892	2,044
		MoMad	0.41 15.10 65.70	56 → 74	2	10	< 1,742
		AUGMECON2	0	0	0	100	-	21h	<	2,044
		2PIPLS/D 5	10	< 1,787
		PDA	0.21	3.03	12.30	79 → 97	1	10	< 1,612
	euclidAB100	2PIPLS/D (A-NMCS) 0.33	9.44	37.80	74 → 99	12	10	< 1,697	1,812
		MoMad	0.36 19.60 85.60	48 → 67	2	10	< 1,400
		AUGMECON2	0	0	0	100	-	22h	<	1,812
		2PIPLS/D (C-LK) 0.12 0.37	1.24	96 → 100	5	11	< 2,225
		PDA	0.20	2.97	12.00	79 → 98	2	11	< 2,008
	euclidCD100	2PIPLS/D (A-NMCS) 0.33 11.60 53.70	71 → 98	18	11	< 2,130	2,268
		MoMad	0.42 23.30 96.70	45 → 63	2	11	< 1,683
		AUGMECON2	0	0	0	100	-	36h	<	2,268
		2PIPLS/D (C-LK) 0.14 0.50	2.67 97 → 99.9	5	11	< 2,488
		PDA	0.22	2.71	9.96	84 → 99	2	11	< 2,319
	euclidEF100	2PIPLS/D (A-NMCS) 0.32	8.13	39.50	80 → 99	12	11	< 2,373	2,530
		MoMad	0.48 24.00 102.00	49 → 70	2	11	< 1,967
		AUGMECON2	0	0	0	100	-	28h	<	2,530
		2PIPLS/D (C-LK) 0.12 0.49	1.82 95 → 99.8	12	14	< 2,981
		PDA	0.16	2.01	7.21	82 → 97	2	14	< 2,762
	ClusterAB100	2PIPLS/D (A-NMCS) 0.29	5.78	16.20	77 → 98	3	14	< 2,850	3,036
		MoMad	0.39 15.90 51.90	51 → 70	34	15	< 2,454
		AUGMECON2	0	0	0	100	-	28h	<	3,036

Table 5

 5

	Instance	Algorithm	I (%) (10 -4 ) I -H	I R2	Coverage Nb. of exam. Time RAM X all (%) sol. (10 6 ) (s) (GB)	| Y nd |
		2PIPLS/D (C-LK) 0.39 0.25 1.53 74 → 99.2	1		< 1 1,469
		PDA	0.63	1.14	4.90	46 → 93	1		< 1 1,161
	rdAB100	MoMad	2.20	8.53 44.30	10 → 18	1		< 1	641	1,707
		2PIPLS/D (A-NMCS) 3.70 14.10 52.50	06 → 51	19		< 1 1,121
		AUGMECON2	0	0	0	100	-	18h	< 4	1,707
		2PIPLS/D (C-LK) 0.37 0.22 1.28 78 → 99.5	1		< 1 1,620
		PDA	0.69	1.18	5.24	48 → 93	1		< 1 1,258
	rdCD100	MoMad	2.23	7.54 43.20	9 → 16	1		< 1	660	1,850
		2PIPLS/D (A-NMCS) 4.05 12.90 42.90	10 → 56	18		< 1 1,182
		AUGMECON2	0	0	0	100	-	21h	< 4	1,850
		2PIPLS/D (C-LK) 0.42 0.41 1.77	69 → 99	2		< 1 1,596
		PDA	0.75	1.53	6.68	40 → 90	1		< 1 1,221
	rdEF100	MoMad	2.48	8.74 46.20	9 → 15	1		< 1	664	1,882
		2PIPLS/D (A-NMCS) 4.70 17.20 66.10	4 → 32	21		< 1 1,152
		AUGMECON2	0	0	0	100	-	24h	< 4	1,882
		2PIPLS/D (C-LK) 0.28 0.16 0.40 87 → 99.8	3		< 1 1,714
		PDA	0.46	0.64	1.38	66 → 96	1		< 1 1,461
	mixedGG100	MoMad	1.52	5.14 21.80	25 → 41	1		< 1	983	1,848
		2PIPLS/D (A-NMCS) 2.49	5.72 11.00	48 → 79	18		< 1 1,441
		AUGMECON2	0	0	0	100	-	20h	< 4	1,848
		2PIPLS/D
	mixedHH100

.8 -Comparison between 2PIPLS/D, PDA, MoMad and AUGMECON2 performance on Euclidean and clustered bi-objective instances of size 100.

(C-LK) 0.35 0.24 0.65 83 → 99.2

						4		< 1 1,920
	PDA	0.55	0.81	2.42	65 → 96	1		< 1 1,698
	MoMad	1.19	4.40 21.30	28 → 42	1		< 1 1,200	2,108
	2PIPLS/D (A-NMCS) 2.74	5.42 14.50	49 → 83	16		< 1 1,692
	AUGMECON2	0	0	0	100	-	19h	< 4	2,108
	2PIPLS/D
	mixedII100

(C-LK) 0.33 0.11 0.71 89 → 99.8

						4		< 1 1,768
	PDA	0.45	0.62	3.28	64 → 97	1		< 1 1,499
	MoMad	1.33	4.86 23.80	25 → 38	1		< 1 1,019	1,883
	2PIPLS/D (A-NMCS) 3.46	6.25 15.80	43 → 85	20		< 1 1,518
	AUGMECON2	0	0	0	100	-	22h	< 4	1,883

Table 5

 5

	.9 -Comparison between 2PIPLS/D, PDA, MoMad and AUGMECON2 performance on random and
	mixed bi-objective instances of size 100.

Table 5 .

 5 10 -Comparison between 2PIPLS/D, PDA and MoMad performance on large-size Euclidean and clustered bi-objective instances.

Table 5 .

 5 11 -Comparison between 2PIPLS/D, PDA and MoMad performance on mixed and random biobjective instances of size 300 and 500.

Table 5 .

 5 12 -Comparison between 2PIPLS/D, PDA, MoMad and PD-TPLS performance on Euclidean and clustered tri-objective instances of size 50 and 100.

	Instance	Algorithm	I (%) (10 -3 ) I -H	I R2	Coverage Nb. of exam. Time RAM (%) sol. (10 6 ) (s) (GB)	X all	| Y nd |
		2PIPLS/D (C-LK) 1.12 1.75	106	2 → 25	293	2,640 < 1 20,929
		PDA	1.22	1.91	114	1 → 18	197	2,668	3.0	20,347
	euclidABC300	PD-TPLS	2.35	2.23	126	2 → 22	7,052	2,667 < 1 18,146	456,433
		MoMad	2.15	3.56	188	0 → 1	399	3,092	2.9	18,451
		2PIPLS/D (A-NMCS) 2.05	5.22	350	0 → 1	573	2,640 < 1 20,204
		2PIPLS/D (C-LK) 1.15 1.66 93.60	2 → 29	318	2,715 < 1 21,670
		PDA	1.29	1.96	109	1 → 19	212	2,716	3.0	20,938
	euclidDEF300	PD-TPLS	2.37	2.17	119	2 → 27	7,467	2,743 < 1 18,711	415,231
		MoMad	2.18	3.53	187	1 → 1	404	2,971	2.9	19,224
		2PIPLS/D (A-NMCS) 2.06	5.12	340	0 → 2	514	2,715 < 1 20,990
		2PIPLS/D (C-LK) 1.15 1.75	102	2 → 27	559	2,861 < 1 27,163
		PDA	1.31	2.07	116	1 → 19	261	2,862	3.0	25,933
	euclidG-3-300	PD-TPLS	2.44	2.44	133	2 → 25	7,338	2,890 < 1 22,753	552,917
		MoMad	2.14	3.80	199	1 → 1	492	3,191	2.9	23,557
		2PIPLS/D (A-NMCS) 2.06	5.26	354	0 → 2	745	2,862	1.0	26,423
		2PIPLS/D (C-LK) 1.26 1.50 89.90	2 → 23	579	3,577	1.0	32,460
		PDA	2.13	1.97	104	1 → 14	367	3,614	3.0	30,791
	ClusterABC300	PD-TPLS	3.18	2.28	120	2 → 21	7,788	3,633 < 1 26,297	657,700
		MoMad	3.96	3.94	185	0 → 1	730	3,614	2.9	28,064
		2PIPLS/D (A-NMCS) 2.41	3.97	268	0 → 2	899	3,577	1.0	31,480
		2PIPLS/D (C-LK) 1.30 1.57	150	1 → 27	668	5,805	2.0	32,974
		PDA	2.39	2.11	182	1 → 13	604	5,807	7.8	30,330
	euclidABC500	PD-TPLS	2.96	2.65	226	2 → 36	12,352	5,805 < 1 23,381	523,721
		MoMad	4.10	5.48	444	0 → 1	865	5,980	7.7	19,872
		2PIPLS/D (A-NMCS) 2.65	7.36	838	0 → 0	1,380	5,805	2.0	30,491
		2PIPLS/D (C-LK) 1.24 1.48	143	1 → 26	641	5,894	1.4	23,791
		PDA	2.10	1.90	174	1 → 12	455	5,896	7.8	22,226
	euclidDEF500	PD-TPLS	2.84	2.22	201	2 → 40	12,149	6,295 < 1 18,418	390,954
		MoMad	4.12	4.58	384	0 → 1	763	5,613	7.7	16,727
		2PIPLS/D (A-NMCS) 2.41	7.17	823	0 → 0	1,028	5,894	2.0	22,324
		2PIPLS/D (C-LK) 1.26 1.68	170	1 → 20	692	5,360	2.0	32,802
		PDA	2.14	2.17	194	0 → 9	598	5,362	7.8	30,545
	euclidG-3-500	PD-TPLS	2.91	2.64	236	2 → 30	12,180	5,360 < 1 23,749	606,916
		MoMad	4.07	5.45	448	0 → 0	894	6,454	7.7	20,400
		2PIPLS/D (A-NMCS) 2.58	7.26	835	0 → 0	1,387	5,360	2.0	30,739
		2PIPLS/D (C-LK) 1.22 1.02	114	2 → 29	826	6,849	2.0	43,685
		PDA	4.71	2.22	158	1 → 11	857	6,524	7.8	37,840
	ClusterABC500	PD-TPLS	4.28	2.48	198	2 → 37	12,004	6,522 < 1 28,053	657,038
		2PIPLS/D (A-NMCS) 3.11	5.19	635	0 → 0	1,648	6,849	2.0	41,059
		MoMad	7.43	5.26	348	0 → 0	1,451	9,068	7.7	28,890

Table 5 .

 5 13 -Comparison between 2PIPLS/D, PDA, MoMad and PD-TPLS performance on Euclidean and clustered tri-objective instances of size 300 and 500.

	Instance	Algorithm	I (%) (10 -3 ) I -H	I R2	Coverage Nb. of exam. Time RAM (%) sol. (10 6 ) (s) (GB)	X all	| Y nd |
		2PIPLS/D (C-LK) 0.89 0.02	0.30	88 → 97	303	212	< 103,095
		2PIPLS/D (A-NMCS) 1.08	0.05	0.40	91 → 99.5	384	212	< 106,163
	rdA-3-50	PDA	1.08	0.16	2.31	56 → 92	67	210	<	74,105	114,490
		MoMad	1.85	1.16	14.40	27 → 46	75	210	<	53,634
		PD-TPLS	2.83	2.73	41.40	8 → 9	1,058	784	<	22,293
		2PIPLS/D (C-LK) 0.88 0.02	0.35	88 → 97	375	198	<	76,640
		2PIPLS/D (A-NMCS) 1.38	0.08	0.57	92 → 99.8	431	198	<	79,554
	rdB-3-50	PDA	1.20	0.14	1.91	63 → 94	52	197	<	58,846	84,992
		MoMad	2.14	1.22	16.30	27 → 47	54	197	<	39,589
		PD-TPLS	3.01	2.89	46.70	8 → 9	1,047	943	<	17,478
		2PIPLS/D (C-LK) 0.80 0.02	0.34	88 → 97	320	197	<	93,044
		2PIPLS/D (A-NMCS) 1.00	0.05	0.67	92 → 99.7	428	197	<	96,437
	rdC-3-50	PDA	1.19	0.14	2.06	60 → 93	61	194	<	69,584	102,866
		MoMad	1.96	1.03	16.20	29 → 50	67	194	<	49,902
		PD-TPLS	3.32	2.57	47.00	8 → 9	1,023	889	<	20,651
		2PIPLS/D (C-LK) 1.20 0.97 32.90	13 → 29	223	883	<	38,274
		PDA	1.52	1.13	35.20	10 → 42	65	891	<	34,334
	rdABC100	2PIPLS/D (A-NMCS) 3.09	2.03	58.80	9 → 50	1,420	884	<	35,409	287,363
		PD-TPLS	3.54	2.31	73.80	4 → 10	1,951	892	<	22,667
		MoMad	3.90	2.81	73.60	4 → 11	119	979	<	26,218
		2PIPLS/D (C-LK) 1.14 1.20 41.80	7 → 16	167	899	<	39,702
		PDA	1.67	1.37	45.2	5 → 24	74	899	<	35,255
	rdD-3-100	2PIPLS/D (A-NMCS) 3.10	2.21	67.60	5 → 25	1,213	900	<	37,246	562,801
		PD-TPLS	3.53	2.51	80.10	2 → 5	1,926	909	<	24,382
		MoMad	3.73	2.93	81.90	2 → 6	131	986	<	27,867
		2PIPLS/D (C-LK) 2.42 1.15	128	1 → 27	523	3,193	1.6	76,193
		PDA	4.34	1.46	139	1 → 20	578	3,225	3	68,526
	rdABC300	PD-TPLS	7.48	2.37	190	1 → 14	5,948	3,225 <	49,981	1,588,953
		MoMad	14.00 4.52	294	0 → 1	958	4,083	2.9	50,365
		2PIPLS/D (A-NMCS) 17.80 7.19	671	0 → 0	1,262	3,206	1.1	67,884
		2PIPLS/D (C-LK) 2.60 1.18	129	1 → 27	532	3,047	1.6	72,931
		PDA	7.09	1.69	145	1 → 10	554	3,046	3	63,916
	rdD-3-300	PD-TPLS	7.34	2.47	190	1 → 15	6,041	3,076 <	47,112	1,518,306
		MoMad	14.00 4.78	294	0 → 1	892	4,021	2.9	47,777
		2PIPLS/D (A-NMCS) 18.80 7.45	720	0 → 0	1,356	3,059	1.1	64,628
		2PIPLS/D (C-LK) 4.70 1.03	179	2 → 36	1,249	5,956	3.4	87,682
		PDA	14.90 1.96	197	1 → 25	1,205	5,957	7.8	71,506
	rdABC500	PD-TPLS	10.40 2.63	288	1 → 20	10,229	5,955 <	43,666	1,248,086
		MoMad	26.50 6.31	519	0 → 1	1,507	8,039	7.7	39,534
		2PIPLS/D (A-NMCS) 27.40 10.10	1700	0 → 0	989	6,008	2.1	76,483
		2PIPLS/D (C-LK) 4.98 1.05	184	1 → 26	1,316	6,322	3.4	87,142
		PDA	14.80 2.12	206	1 → 17	1,163	6,322	7.8	70,890
	rdD-3-500	PD-TPLS	11.00 2.64	297	1 → 14	10,087	6,320 <	43,813	1,507,910
		MoMad	28.20 6.22	525	0 → 0	1,461	8,076	7.7	40,200
		2PIPLS/D (A-NMCS) 26.40 10.30	1760	0 → 0	1,662	6,376	2.1	75,691

Table 5 .

 5 14 -Comparison between 2PIPLS/D, PDA, MoMad and PD-TPLS performance on random triobjective instances.

Table 6

 6

	Parameter	Module of 2PIPLS/D concerned Selected range of values	Final value
	SO optimizer	-	{IDA*,ILS,A-NMCS}	ILS
	perturbation move	perturbation step (phase 2)	-	10-department move
	min. acceptance rate threshold α	A-MDW	{5%, 25%, 50%}	25%
	data perturbation coefficient δ	SO optimizer (phase 2)	{0%, 5%}	0%
	maximum initial size of a part σ	P-PLS	{5, 50, +∞}	5
	maximum neighborhood structure size k	PLS-VND	{1, 2, 3}	2
	independent-pls	PLS-VND	{no, yes}	yes
	first-dominating	PLS-VND	{no, yes}	yes
	explore-dominated	PLS-VND	{no, yes}	yes
	tolerance for dominance relations	-	-	1%
	archive	-	-	SANDRA

.2 -Parameters of 2PIPLS/D, their respective selected range of values and final values.

  Dans cette thèse, nous nous intéressons à la conception de structures de données et de méta-heuristiques pour trouver l'approximation d'un ensemble ecace de problèmes MOCO. Le point principal de la thèse est de proposer des méthodes nouvelles et ecaces (en termes de temps et de qualité d'approximation), indépendantes autant que possible du problème traité, et scalables tant dans la taille que dans le nombre d'objectifs de l'instance. En eet, nous ne nous sommes pas limités au cas bi-objectif et avons considéré des problèmes avec jusqu'à 5 objectifs. De plus, les méthodes proposées sont modulaires, en le sens où elles peuvent être utilisés indépendamment les unes des autres. En raison des récents succès de la recherche locale sur des problèmes MOCO durs, nous sommes particulièrement intéressés par l'introduction de nouveaux algorithmes pour la recherche locale MO, les méthodes d'optimisation mono-objectif et les structures de données. Comme axe secondaire, compte tenu de l'émergence récente de méthodes de recherche de Monte-Carlo ecaces sur de nombreux problèmes d'optimisation mono-objectif, nous nous intéressons également à la combinaison des méthodes de recherche Monte-Carlo avec la recherche locale MO.Plan de la thèseLe chapitre 1 rappelle les dénitions et notions MOCO fondamentales. Le chapitre 2 présente une vue d'ensemble des méthodes d'optimisation des problèmes MOCO, en mettant l'accent sur les méta-heuristiques. Le chapitre présente également l'Etat de l'art des méthodes sur le Problème du Voyageur de Commerce MO (MOTSP), en mettant l'accent sur les méta-heuristiques, puis expose l'Etat de l'art des archives, qui sont des structures de données gérant un ensemble de solutions incomparables. Le chapitre 3 traite des nouvelles archives proposées : l'AVL-Archive pour les problèmes d'optimisation bi-objectif et la NDR*-Archive pour le cas général. Les résultats expérimentaux sur les benchmarks articiels et sur le MOTSP sont présentés. Le chapitre 4 introduit les nouvelles méthodes proposées pour optimiser les problèmes MOCO : une nouvelle méta-heuristique MO appelée 2 Phase Iterated Pareto Local Search with Decomposition (2PIPLS/D), intégrant l'Adaptive Maximally Dispersed set of Weights (A-MDW) qui permet de générer une population initiale de solutions, la Partitioned Pareto Local Search (P-PLS) comme technique d'accélération pour la PLS, et quelques modications sur les méthodes monoobjectif an améliorer leur ecacité sur les problèmes MOCO. Le chapitre 5 est consacré à l'application de 2PIPLS/D au MOTSP sur un benchmark d'instances bi-objectif et triobjectif, et propose une preuve empirique de la convexité globale pour le MOTSP. Enn, le chapitre 6 introduit la version MO du problème de cartographie des régions françaises et montre l'application de 2PIPLS/D à ce nouveau problème à cinq objectifs.1 Concepts fondamentaux de MOCO : Résumé Ce chapitre rappelle d'abord la dénition formelle d'un problème MOCO, puis les notions de base telles que les relations de dominance, le concept de non-dominance, les points idéal et nadir et les solutions (non) supportées. Des techniques fondamentales sont également introduites, telles que les fonctions d'agrégation et la génération de poids. Enn, certains problèmes MOCO classiques sont introduits. 2 Méthodes de MOCO : Résumé Ce chapitre propose une vue d'ensemble des diérentes méthodes existant dans MOCO, en mettant l'accent sur les méta-heuristiques. Tout d'abord, la notion d'indicateur de qualité pour un ensemble de points est introduite, et les indicateurs utilisés pour nos futures expériences sont détaillés. Ensuite, diérentes classes de méta-heuristiques sont présentées parmi lesquelles la recherche locale et la recherche Monte-Carlo sont largement décrites. En particulier, nous proposons une catégorisation claire des diérentes méthodes de recherche locale MO. Enn, est réalisé un état de l'art des méthodes d'optimisation pour le MOTSP ainsi que sur les archives. Nous avons proposé deux nouvelles archives, l'AVL-Archive spécialisée dans le cas biobjectif, et la NDR *-Archive pour le cas général. Les deux structures sont auto-équilibrées et ont deux versions : une version générale adaptée à toute tâche d'optimisation MO ; et une version adaptative, spécialement conçue si une présomption de localisation temporelle et spatiale existe entre les solutions présentées à l'archive. Ces archives ont été testées expérimentalement et comparées aux archives de l'état de l'art sur un grand nombre d'instances simulant la génération de points d'une méta-heuristique MO, et embarquées à l'intérieur de la recherche locale Pareto (PLS) appliquée au MOTSP avec jusque 5 objectifs. L'AVL-Archive surpasse toutes les autres archives dans le cas bi-objectif et sa version adaptative fonctionne légèrement mieux que la liste triée lorsqu'elles est utilisée au sein de la PLS. NDR * -Archive fonctionne mieux que les concurrents dans le cas général, en particulier lorsque 4 objectifs ou moins sont considérés et que le nombre de points dominés est plus grand que le nombre de points non dominés. La version adaptative de NDR*-Archive est beaucoup plus ecace que ses concurrents lorsqu'elle est embarquée dans la PLS, en particulier quand 3 ou 4 objectifs sont considérés.

	3	Nouvelles archives : Résumé

6

  Application de 2PIPLS/D au MOFRMP : Résumé Dans ce chapitre, nous nous intéressons à la récente réforme territoriale des régions françaises qui s'est traduite par l'aectation des départements à de nouvelles régions plus grandes. A partir de l'observation que certains départements sont plus attirés par d'autres régions que leur région d'aectation actuelle, le but de ce chapitre était de tenter d'identier ces départements en optimisant un nouveau problème multi-objectif appelé Problème de Cartographie des Régions Françaises MO (MOFRMP). Le problème consiste à trouver des cartes alternatives en optimisant cinq objectifs, basés sur des indicateurs économiques et nanciers mesurant la force des interactions entre les départements aectés à une même région, ainsi que les poids économiques et démographiques de chaque région. Nous avons appliqué 2PIPLS/D à ce problème et testé la recherche locale itérée (ILS) et A-NMCS comme méthodes d'optimisation mono-objectif. Nous avons constaté que 2PIPLS/D avec ILS surpasse 2PIPLS/D avec A-NMCS. Une approximation de l'ensemble ecace a été générée avec les diérentes exécutions de 2PIPLS/D. Cependant, nous avons trouvé que les cartes (potentiellement) ecaces trouvées ont beaucoup trop de départements de différence avec la carte actuelle, ce qui rend irréaliste de les proposer comme alternative à la carte actuelle. Au lieu de cela, nous avons construit un indicateur basé sur l'approximation des solutions ecaces trouvées, qui vise à identier les départements les plus attirés par d'autres régions que leur région courante à laquelle ils appartiennent. En particulier, nous avons constaté que le Gard (30), la Haute-Marne (52) et les Deux-Sèvres (79) sont particulièrement attirés par d'autres régions.Le MOFRMP soulève une question importante : la carte actuelle des régions pourrait-elle être améliorée ? Le travail proposé dans ce chapitre correspond seulement à une réponse préliminaire à cette question. Nous pensons qu'une nouvelle formulation du MOFRMP est nécessaire pour obtenir des cartes alternatives réalistes. Premièrement, il nous semble important de ne pas limiter ce problème aux seuls critères économiques et nanciers. A titre d'exemple, les échanges culturels entre départements pourraient être envisagés, ou l'intensité globale des mouvements de personnes entre les départements, et pas seulement les trajets domicile-travail. Deuxièmement, il est impératif d'obtenir les préférences des décideurs quant à l'importance relative des diérents critères considérés. Troisièmement, nous pensons que toute carte alternative doit proposer un nombre très limité de réaectations de départements par rapport à la carte actuelle. Si le nombre maximum de réaectations est limité à 3 ou 4 par exemple, le problème devient assez facile et il semble qu'une méthode d'optimisation ne soit pas nécessaire. En eet, dans ce cas, une simple énumération des solutions est susante, puis un ltrage pour ne garder que les solutions ecaces, et enn l'utilisation d'une méthode d'aide à la décision multi-critère en considérant les préférences des décideurs préalablement obtenues. En revanche, si un nombre plus élevé de réaectations est accepté (c'est-à-dire 5 ou plus), le nombre de solutions réalisables semble trop important pour une simple énumération. Dans ce cas, une méthode d'optimisation MO est nécessaire et 2PIPLS/D pourrait être adapté à cette nouvelle formulation du MOFRMP. dans le cadre de l'optimisation combinatoire multi-objectif (MOCO), cette thèse a proposé un certain nombre de nouvelles méthodes d'approximation et de structures de données pour les problèmes de MOCO de grande taille. Tout d'abord, les contributions de la thèse sont résumées, puis un certain nombre de perspectives sont suggérées. Contributions 1. Nous avons proposé deux nouvelles archives : l'AVL-Archive pour le cas bi-objectif et la NDR *-Archive pour un nombre quelconque d'objectifs ; ainsi que leurs versions adaptatives utilisant les concepts de localisation temporelle et spatiale, et donc spécialement conçues pour la PLS. Nous avons comparé ces archives aux meilleures archives connues et nous obtenons de meilleurs résultats que les concurrents, faisant de l'AVL-Archive et de la NDR * -Archive et leurs versions adaptatives, les archives les plus ecaces jusqu'à 5 objectifs. 2. Nous avons présenté une nouvelle méthode généralisant le concept de MDW en le rendant plus adaptatif de sorte que la méthode continue de générer des poids jusqu'à ce que la méthode d'optimisation mono-objectif optimisant les problèmes de somme pondérée associés ne soit plus ecace. 3. Nous avons introduit la recherche locale Pareto partitonnée (P-PLS), qui vise à accélérer PLS-VND au travers d'un partitionnement de l'ensemble de solutions à explorer, et une restriction intelligente de la structure de voisinage de PLS-VND basée sur la présomption de convexité globale sur le problème traité. 4. Nous avons suggéré quelques modications pour tout optimiseur mono-objectifs an d'améliorer sa capacité à trouver des solutions ecaces dans les problèmes MOCO, en particulier en mémorisant les solutions générées au cours du processus d'optimisation. Sur la base de ces spécications, nous avons proposé une nouvelle version de NMCS, appelée A-NMCS, mieux adaptée aux problèmes MOCO que NMCS. 5. Nous avons présenté une nouvelle méta-heuristique appelée 2PIPLS/D. Au cours de la première phase, A-MDW est utilisé comme méthode d'initialisation et P-PLS construit une partition pour accélérer PLS-VND. A chaque itération de la seconde phase, un ensemble de solutions est tout d'abord généré par l'optimisation de plusieurs problèmes de somme pondérée perturbés, puis PLS-VND est lancé à partir de cet ensemble. 2PIPLS/D gère diérents modes et stratégies d'exploration pour PLS-VND, et intègre un système d' -archive qui permet une bonne distribution dans l'espace des objectifs des points générés et limite la taille de l'approximation. 6. Nous avons implémenté 2PIPLS/D pour le MOTSP. La méthode a été comparée aux méthodes de l'Etat de l'art sur des instances du TSP à deux objectifs et trois objectifs. Les résultats expérimentaux montrent que 2PIPLS/D surpasse ses concurrents sur toutes les instances testées, à l'exception de 5% d'entre elles où notre propre méthode PDA proposée dans un pécédent article et 2PIPLS/D ont des performances similaires. P-PLS fournit une performance étonnamment bonne car il réduit le nombre de solutions explorées de 98% en moyenne, comparé à une absence de partitionnement. Dans la continuation des travaux de Borges et Hansen, nous avons conrmé expérimentalement l'hypothèse de convexité globale pour le MOTSP sur un certain nombre d'instances bi-objectif et tri-objectif. Dans la suite des travaux de Lust et Teghem, nous avons constaté que les arêtes présentes dans les solutions ecaces sont de bonne qualité par rapport aux autres arêtes. 7. Nous avons implémenté 2PIPLS/D pour un nouveau problème lié à la récente réforme territoriale des régions françaises, le FRMP, pour lequel nous avons proposé une formulation MO avec 5 objectifs. Nous avons détecté un certain nombre de départements plus attirés par une région que leur région à laquelle ils appartiennent actuellement. 8. Pour le MOTSP comme pour le MOFRMP, 2PIPLS/D avec A-NMCS est surpassé dans la plupart des cas par 2PIPLS/D avec une méthode basée sur la recherche locale.

Conclusion S'inscrivant

  Concernant 2PIPLS/D, au lieu d'utiliser PLS(-VND), il pourrait être intéressant d'utiliser une méthode d'optimisation combinatoire exacte. En fait, la méthode de partitionnement introduite dans P-PLS est indépendante du concept de PLS (elle a en eet été initialement conçue comme telle). Par conséquent, l'idée consiste à exécuter un algorithme de Branch et Bound MO ou un algorithme de programmation dynamique MO (par exemple) à partir de l'espace de recherche réduit fourni par le système de partitionnement. Notez que les nouvelles archives que nous avons proposées seraient d'un grand intérêt si une méthode de programmation dynamique MO est utilisée. Par exemple, pour le MOTSP, on pourrait utiliser une version MO de la méthode de programmation dynamique basée sur la branch-decomposition de Cook et Seymour. Pour le MO 0-1 Knapsack Problem, la méthode utilisée pourrait être la méthode de Programmation Dynamique MO de Bazgan et al.. Nous croyons que cette direction de recherche est prometteuse étant donnée la grande réduction de l'espace de recherche permise par le système de partitionnement obtenue sur le MOTSP.RésuméDe nombreux problèmes d'optimisation combinatoire considèrent plusieurs objectifs, souvent conflictuels. Cette thèse s'intéresse à l'utilisation de méthodes de recherche locale, de structures de données et de recherche Monte-Carlo pour la recherche de l'ensemble des solutions efficaces de tels problèmes, représentant l'ensemble des meilleurs compromis pouvant être réalisés en considération de tous les objectifs. Nous proposons une nouvelle méthode d'approximation appelée 2-Phase Iterated Pareto Local Search based on Decomposition (2PIPLS/D) combinant les concepts de recherche locale Pareto (PLS) et de décomposition.La PLS est une descente de recherche locale adaptée au multiobjectif, et la décomposition consiste en la subdivision du problème multi-objectif en plusieurs problèmes mono-objectif. Deux méthodes d'optimisation mono-objectif sont considérées: la recherche locale itérée et la recherche Monte-Carlo imbriquée. Deux modules principaux sont intégrés à 2PI-PLS/D. Le premier généralise et améliore une méthode existante et génère un ensemble initial de solutions. Le second réduit efficacement l'espace de recherche et permet d'accélérer la PLS sans négliger la qualité de l'approximation générée. Nous introduisons aussi deux nouvelles structures de données gérant dynamiquement un ensemble de solutions incomparables, la première est spécialisée pour le cas bi-objectif et la seconde pour le cas général. 2PIPLS/D est appliquée au Problème du Voyageur de Commerce bi-objectif et triobjectif et surpasse ses concurrents sur les instances testées. Ensuite, 2PIPLS/D est appliquée à un nouveau problème avec cinq objectifs en lien avec la récente réforme territoriale d'agrandissement des régions françaises.

	Mots Clés
	Optimisation combinatoire multi-objectif
	Méta-heuristique
	Recherche locale
	Structures de données
	Décomposition
	Recherche Monte-Carlo
	Problème du Voyageur de Commerce

http://iridia.ulb.ac.be/∼manuel/hypervolume

http://www.wfg.csse.uwa.edu.au/hypervolume/index.html#data

https://en.wikipedia.org/wiki/Locality_of_reference

https://www.iwr.uni-heidelberg.de/groups/comopt/software/TSPLIB95/

http://dimacs.rutgers.edu/Challenges/TSP/

http://www-desir.lip6.fr/~lustt/Research.html#Main

http://www.tsp.gatech.edu/concorde

http://www.sls-book.net/implementations.html

https://sites.google.com/site/kflorios/motsp

http://www.vie-publique.fr/decouverte-institutions/institutions/collectivites-territoriales/principes-collectivitesterritoriales/qu-est-ce-que-decentralisation.html

2 http://www.assemblee-nationale.fr/connaissance/constitution.asp

https://www.interieur.gouv.fr/Archives/Archives-sous-sites/Reforme-des-collectivites-territoriales/La-reforme/Questionsles-plus-frequentes

4 http://www.gouvernement.fr/action/la-reforme-

territoriale 5 http://www.strategie.gouv.fr/publications/reforme-territoriale-coherence-

economique-regionale 6 http://www.strategie.gouv.fr/point-de-vue/

repenser-decoupage-regional 7 http://www.strategie.gouv.fr/point-de-vue/repenser-decoupage-regional, http://www.strategie.gouv.fr/publications/une-evaluation-de-coherence-economique-interne-regions, http://www.strategie.gouv.fr/sites/strategie.gouv.fr/files/atoms/files/dt_2015-

01_rrgions_cbae_rev_selda_final.pdf 8 http://www.strategie.gouv.fr/

based on the Diane database: www.bvdinfo.com/fr-fr/our-products/company-information/national/diane

based on the Insee 2005 database on GDP

https://www.collectivites-locales.gouv.fr/files/files/statistiques/brochures/bpr_2016.pdf

http://www.caissedesdepotsdesterritoires.fr/cs/ContentServer?pagename=Localtis/LOCActu/ArticleActualite &jid=1250271788545&cid=1250271787054&nl=1

https://adnormandie.fr/normandie-participations/

http://www.strategie.gouv.fr/point-de-vue/repenser-decoupage-regional, http://www.strategie.gouv.fr/publications/une-evaluation-de-coherence-economique-interne-regions, http://www.strategie.gouv.fr/sites/strategie.gouv.fr/files/atoms/files/dt_2015-01_rrgions_cbae_rev_selda_final.pdf

http://france3-regions.francetvinfo.fr/grand-est/francois-fillon-nouvelle-reforme-territoriale-1143001.html

[http://www.dna.fr/social/2017/04/29/medef-alsace-la-nouvelle-region-est-trop-grande||http://www.dna.fr/social/2017/04/29/medefalsace-la-nouvelle-region-est-trop-grande]

Remerciements

Marie-Jo Bellosta me m'avoir

Algorithme 32 : PLS-VND [generalized] Input : set of neighborhood structures (N 1 , ..., N k ), boolean first-dominating, boolean explore-dominated, set of solutions to explore X, global archive X all Output : X all X all ←AddAll( X, X all ) j ← 1 while j ≤ k do while X = ∅ do X new ←PLS-iteration( N j , first-dominating, explore-dominated, X, X all )

return X all of dominated solutions. Indeed, as previously indicated, as the PLS-VND uses a temporary archive to store the solutions to explore, thus they are protected from a removal from the global archive X all .

Algorithme 33 : PLS-iteration [generalized vanilla] Input : neighborhood structure N j , boolean first-dominating, boolean explore-dominated, set of solutions to explore X, global archive X all Output : archive of new solutions X new

Algorithms 32 and 33 present the new version of PLS-VND with two simple modifications (highlighted in pseudo-code with red color) compared to the original version, consisting in:

1. The introduction of the input parameter explore-dominated, set to true if the exploration of the neighborhood of dominated solutions is permitted.

Π ←InitializeSubProblems(Lλ all , X all ) // Phase 2: repeat // Global perturbation step:

if independent-pls then // PLS-VND in independent mod:

X all ←AddAll( X pls , X all ) else // PLS-VND in dependent mod:

As the best known meta-heuristic for bi-objective TSP not proposed by us, MoMad [START_REF] Ke | A simple yet efficient multiobjective combinatorial optimization method using decompostion and pareto local search[END_REF] is selected to run on bi-objective and tri-objective instances. As proposed in [START_REF] Ke | A simple yet efficient multiobjective combinatorial optimization method using decompostion and pareto local search[END_REF], the maximum number of iterations for PLS is set to 10. During the decomposition phase, MoMad uses the MDW method to generate its set of weights. For bi-objective instances, the number of sub-problems is set to min (n, 600) as suggested in [START_REF] Ke | A simple yet efficient multiobjective combinatorial optimization method using decompostion and pareto local search[END_REF]. As done in [START_REF] Cornu | Perturbed decomposition algorithm applied to the multi-objective traveling salesman problem[END_REF], we fixed the number of subproblems to ( 50+3-1 3-1 ) = 1326 for (tri-objective) instances of size 50, and ( 60+3-1 3-1 ) = 1891 for (tri-objective) instances of size greater than or equal to 100. The number of iterations is fixed to 500 for all bi-objective instances and for tri-objective instances of size n < 100. For larger-sized tri-objective instances (n ≥ 100), the number of iterations is fixed to 1000. MoMad is implemented in C/C++.

As the best known meta-heuristic for tri-objective TSP not proposed by us, PD-TPLS [START_REF] Paquete | Design and analysis of stochastic local search for the multiobjective traveling salesman problem[END_REF]] is selected to run on tri-objective instances. PD-TPLS also uses MDW to generate its set of weights, and we set the number of weights to ( 150+3-1 3-1 ) = 11476 for all instances, in order to avoid the clustering effect described in [START_REF] Paquete | Design and analysis of stochastic local search for the multiobjective traveling salesman problem[END_REF]. For each generated weight, PD-TPLS optimizes the corresponding weighted sum problem by calling C-LK as suggested in [START_REF] Paquete | Design and analysis of stochastic local search for the multiobjective traveling salesman problem[END_REF] as future works, instead of the 3-opt first improvement used in the original method. Internal tests have shown that PD-TPLS using C-LK gives better results. PD-TPLS is implemented in C/C++.

As the best known meta-heuristic for MOTSP, PDA [START_REF] Cornu | Perturbed decomposition algorithm applied to the multi-objective traveling salesman problem[END_REF] is selected to run on bi-objective and tri-objective instances. PDA also uses MDW and uses the same number of sub-problems as MoMad. The running time of PDA is limited to the minimum running time between MoMad and PD-TPLS. PDA is implemented in C/C++.

Experimental results

2PIPLS/D, PDA, MoMad and PD-TPLS (resp. AUGMECON2) have been run 20 (resp. 1) times on the MOTSP test benchmark presented in Section 5.1. Tables 5.8 to 5.14 collect key information about the performance of the different methods. More precisely, the tables report for each method:

• the average value of I , I - H , and I R2 over all runs;

• the average coverage -i.e. the proportion of (potentially) efficient solutions in a given approximationover all runs, and the coverage of the union of the runs;

• the average number of solutions examined;

• the average running time;

• the average RAM utilized;

• the average size of the final approximation set X all generated;

• the size of the (exact when p = 2 and n = 100, approximated otherwise) non-dominated set Y nd . When the (exact) non-dominated set is not known, we recall that its approximation is built by merging the final approximation sets provided by all the methods. Table 6.3 -The top 10 departments with the lowest membership score (i.e. the departments the most attracted to other regions than their current region of assignment).

to its current region of assignment .The membership score of a department d ∈ D ranges from 0% to 100%, where 0% indicates that d has no membership towards its current region of assignment and thus is completely attracted to other regions, while 100% indicates that d is always assigned to its current region and thus is absolutely not attracted by another region. We obtain the map in Figure 6.6 and Table 6.3 lists the top 10 departments with the lowest membership score and the region to which they are the most attracted.

Given the multiple knowledge (economic, financial, political, administrative and many others) necessary to master the question of the need (or not) of the re-assignment of a department to another region than its current region of assignment, it is difficult for us to know if the membership score is a consistent evaluation for such a question. Anyway, it is interesting to note that a large number of departments currently assigned to the region Grand Est (67) have a very low membership score. Besides, politicians regularly suggest 1819 to reduce the size of this region.