programmation par contraintes

Thèse pour obtenir le grade de : Docteur en Sciences par Fatima Zohra LEBBAH

Programmation par contraintes appliquée à des problèmes issus des finances (Approches de résolution de contraintes pour l’optimisation des portefeuilles financiers)

Thèse soutenue le 16 Juin 2015 devant le jury composé de :

M.

M.Fayçal Khelfi

Professeur

(Examinateur)

Université d’Oran 1, Ahmed Ben Bella M.

Belaid Benhamou

Maître de Conférences (HDR)

(Examinateur)

Université de Aix-Marseille, France M.

Meziane Aider

Professeur

(Examinateur)

Université des Sciences et de la Technologie de Houari Boumediene (USTHB) M.

AMIR Abdessamad

Maître de Conférences (A)

(Examinateur)

Université Abdelhamid Ibn Badis Mostaganem M.

Lakhdar Loukil

Maître de Conférences (A)

(Examinateur)

Université d’Oran 1, Ahmed Ben Bella M.

Khalid Hachemi

Maître de Conférences (A)

(Invité)

Université d’Oran 2 (IMSI) M.

Yahia Lebbah

Professeur

(Directeur de Thèse)

Université d’Oran 1, Ahmed Ben Bella Laboratoire d’Informatique et des Technologies de l’Information d’Oran (LITIO).

Remerciements

Je tiens tout d’abord à remercier M. Mohammed Fayçal Khelfi qui m’a fait l’honneur de présider le jury de ma soutenance et de juger le travail réalisé. J’adresse mes sincères remerciements aux membres du jury : M. Belaid Benhamou, M. Meziane Aider, M. Amir Abdessamad, M. Lakhdar Loukil et M. Khalid Hachemi d’avoir accepté d’examiner ce travail.

Je remercie mon frère et directeur de thèse M. Yahia Lebbah de m’avoir proposé ce sujet et de m’avoir guidée et conseillée durant cette thèse. Je le remercie pour sa patience et sa pertinence tout au long de ces années.

Je remercie les membres de l’équipe PCO du laboratoire LITIO qui ont participé à la relecture de ce manuscrit et leurs remarques pertinentes. Je remercie tous ceux qui ont contribué de près ou de loin à l’accomplissement de cette thèse. Je tiens à exprimer ma reconnaissance et ma profonde gratitude à ma famille : mes chères parents qui ont toujours été présents pour moi, mes sœurs, mon frère et leurs petites familles. En particulier, j’adresse un grand merci à Tassadit pour sa patience et de m’avoir toujours soutenue et encouragée à aller vers l’avant.

1

À tous ceux qui y ont cru ...

2

Table des matières I

Etat de l’art

13

1 Ingénierie des finances et la problématique de conception des portefeuilles 1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2 Terminologie financière de base . . . . . . . . . . . . . . . . . . . . . 1.3 Risque financier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.4 Obligations adossées à des actifs (CDO) . . . . . . . . . . . . . . . . 1.4.1 CDO2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.4.2 Optimisation d’un portefeuille financier et le CDO2 . . . . . . 1.5 Modèles ensemblistes de conception des portefeuilles . . . . . . . . . . 1.5.1 Modèle d’optimisation des portefeuilles (OP D) . . . . . . . . 1.5.2 Modèle de conception des portefeuilles (P D) . . . . . . . . . . 1.5.3 Résolution du problème (P D) . . . . . . . . . . . . . . . . . . 1.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

15 15 16 17 17 18 19 20 20 21 22 23

2 Méthodes de résolution 25 2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 2.2 Méthodes locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 2.2.1 Méthodes de recherche locale simple . . . . . . . . . . . . . . 25 2.2.1.1 Recuit simulé . . . . . . . . . . . . . . . . . . . . . . 25 2.2.1.2 Méthode IDWalk . . . . . . . . . . . . . . . . . . . . 26 2.2.1.3 Recherche Tabou . . . . . . . . . . . . . . . . . . . . 27 2.2.2 Méthode de recherche locale à voisinage variable (VNS) . . . . 28 2.2.2.1 Méthode Skewed Varibale Neighbourhood Search (SVNS) 30 2.2.3 Méthode de recherche locale à population GWW . . . . . . . 30 2.2.4 Étude des paysages . . . . . . . . . . . . . . . . . . . . . . . . 31 2.3 Méthodes globales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 2.3.1 Programmation linéaire en nombres entiers (PLNE) . . . . . . 33 2.3.2 Programmation par contraintes (PPC) . . . . . . . . . . . . . 34 2.4 Problème symétrique . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 2.4.1 Symétrie sémantique . . . . . . . . . . . . . . . . . . . . . . . 38 2.4.2 Symétrie syntaxique . . . . . . . . . . . . . . . . . . . . . . . 39 2.5 Élimination des symétries . . . . . . . . . . . . . . . . . . . . . . . . 39 2.5.1 Élimination statique de symétries . . . . . . . . . . . . . . . . 39 2.5.2 Élimination dynamique des symétries globales . . . . . . . . . 41 2.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 3

II

Contribution

45

3 Méthodes approchées pour le problème de conception de portefeuilles 3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2 Modèle matriciel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.3 Exemple de motivation . . . . . . . . . . . . . . . . . . . . . . . . . . 3.4 Composants de base des recherches locales . . . . . . . . . . . . . . . 3.4.1 Fonction coût . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.4.2 Fonctions de voisinage . . . . . . . . . . . . . . . . . . . . . . 3.4.2.1 Fonction de voisinage flip . . . . . . . . . . . . . . . 3.4.2.2 Fonction de voisinage swap . . . . . . . . . . . . . . 3.5 Algorithme glouton pour calculer la solution initiale . . . . . . . . . . 3.6 Méthodes de recherche locale simple . . . . . . . . . . . . . . . . . . . 3.7 Méthodes de recherche locale à voisinage variable (VNS) . . . . . . . 3.7.1 Recherche locale à voisinage variable biaisée (skewed VNS) . . 3.8 Méthode de recherche locale à population GWW . . . . . . . . . . . . 3.9 Etude expérimentale . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.9.1 Mise en œuvre des algorithmes sous INCOP . . . . . . . . . . 3.9.2 Protocole expérimental . . . . . . . . . . . . . . . . . . . . . . 3.9.3 Résultats expérimentaux . . . . . . . . . . . . . . . . . . . . . 3.9.3.1 Expérimentation de l’algorithme glouton . . . . . . . 3.9.3.2 Recherches locales simples . . . . . . . . . . . . . . . 3.9.3.3 Étude du paysage de résolution avec recherche locale simple . . . . . . . . . . . . . . . . . . . . . . . . . . 3.9.3.4 Recherche locale avec voisinage variable . . . . . . . 3.9.3.5 Méthode à population GWW . . . . . . . . . . . . . 3.9.4 Étude des profiles de performance . . . . . . . . . . . . . . . . 3.10 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 Méthodes exactes pour le problème de conception de portefeuilles 4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2 Exemple de motivation . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3 Approche basée sur la Programmation en Nombres Entiers (PLNE) . 4.3.1 Linéarisation du modèle (P D) . . . . . . . . . . . . . . . . . . 4.3.2 Élimination des symétries sur le modèle linéaire . . . . . . . . 4.4 Approche PPC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.4.1 Modélisation du problème (P D) en PPC . . . . . . . . . . . . 4.4.2 Symétries dans le problème (P D) . . . . . . . . . . . . . . . . 4.5 Etude expérimentale . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.5.1 Approche PLNE . . . . . . . . . . . . . . . . . . . . . . . . . 4.5.1.1 L’environnement SCIP . . . . . . . . . . . . . . . . . 4.5.1.2 Résultats expérimentaux . . . . . . . . . . . . . . . . 4.5.2 Approche PPC . . . . . . . . . . . . . . . . . . . . . . . . . . 4.5.2.1 Environnement GECODE . . . . . . . . . . . . . . . 4.5.2.2 Résultats expérimentaux . . . . . . . . . . . . . . . . 4.5.3 Synthèse des résultats . . . . . . . . . . . . . . . . . . . . . . 4.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

47 47 48 49 51 51 51 51 52 53 56 57 58 59 60 60 60 62 62 62 65 70 73 76 82 83 83 84 85 85 86 87 87 88 92 93 93 93 95 95 95 97 99

Table des figures 1.1 1.2 1.3

Exemple de la structure d’un CDO . . . . . . . . . . . . . . . . . . . 18 La structure typique d’un CDO . . . . . . . . . . . . . . . . . . . . . 19 Exemple d’une structure de CDO2 (Bhatt et al., 2005) . . . . . . . . 19

2.1 2.2 2.3 2.4

Illustration de la recherche VNS (Hansen et Mladenovic, 2009) Exemple d’un paysage lisse (Marmion, 2011) . . . . . . . . . . Exemple d’un paysage rugueux (Marmion, 2011) . . . . . . . . Exemple d’un paysage neutre . . . . . . . . . . . . . . . . . .

. . . .

. . . .

29 32 32 33

3.1 3.2 3.3 3.4 3.5

Exemple de la structure matriciel du modèle (P D) . . . . . . . . . Le paysage de l’instance P Dh16, 8, 3, 1i . . . . . . . . . . . . . . . . Le paysage de l’instance P Dh19, 20, 9, 4i . . . . . . . . . . . . . . . Le paysage de l’instance P Dh9, 37, 12, 3i . . . . . . . . . . . . . . . Profile de performance-RLS en fonction des nombres de succès et en en fonction des Temps CPU . . . . . . . . . . . . . . . . . . . . . . Profile de performance-VNS/SVNS en fonction des nombres de succès et en en fonction des Temps CPU . . . . . . . . . . . . . . . . . . . Profiles de performance des méthodes performantes en fonction des nombres de succès et en en fonction des Temps CPU . . . . . . . .

. . . .

49 67 68 69

3.6 3.7 4.1 4.2 4.3

. . . .

. . . .

. 78 . 80 . 81

Comparaison des temps CPU réalisés sous SCIP avec et sans élimination de symétries, en fonction du nombre de variables des instances 94 Comparaison des temps CPU réalisés avec les différentes implémentations PPC, en fonction du nombre de variables des instances . . . . 96 Comparaison des meilleurs temps CPU réalisés sous Gecode et SCIP en fonction du nombre de variables des instances . . . . . . . . . . . . 98

5

6

Liste des tableaux La solution de P Dh10, 37, 14, 6i avec l’approche VNS . . . . . . . . . Le nombre moyen de chevauchements et les temps d’exécution de l’approche de Flener et al. et l’approche VNS sur l’instance P Dh10, 37, 14, 6i 3.3 Les instances expérimentées . . . . . . . . . . . . . . . . . . . . . . . 3.4 Comparaison du nombre de contraintes violées entre une configuration initiale aléatoire et celle générée par l’algorithme 8. . . . . . . . . . . 3.5 Les temps CPU et les nombres de succès . . . . . . . . . . . . . . . . 3.6 Les taux moyen du nombre de contraintes non-satisfaites et du nombre de chevauchements . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.7 Résultats expérimentaux en temps et en nombre de succès . . . . . . 3.8 moy-c and moy-λ results . . . . . . . . . . . . . . . . . . . . . . . . 3.9 Les temps CPU et les nombres de succès . . . . . . . . . . . . . . . . 3.10 Les taux moyens des nombres de contraintes et des chevauchements .

3.1 3.2

4.1

4.2 4.3 4.4 4.5

Les deux solutions générées pour P Dh10, 8, 3, 2i, en appliquant l’approche de Flener et al. sur le modèle avec égalité et l’approche PPC sur le modèle avec inégalités . . . . . . . . . . . . . . . . . . . . . . . La moyenne des chevauchements de l’instance P Dh10, 8, 3, 2i . . . . . Les résultats expérimentaux obtenus avec SCIP . . . . . . . . . . . . Les résultats expérimentaux obtenus avec Gecode . . . . . . . . . . Les meilleurs résultats expérimentaux obtenus avec l’approche exacte

7

50 50 61 63 64 65 71 72 74 75

84 84 94 96 98

8

Introduction générale La résolution de contraintes est un problème combinatoire qui intéresse de nombreux domaines, à savoir l’ordonnancement des tâches, la planification, l’emploi du temps, la vérification des systèmes, etc. Dans ce mémoire, nous nous intéressons à un système de contraintes issu de l’ingénierie des finances, à savoir le problème de conception des portefeuilles financiers. Il modélise une problématique critique dans la gestion équitable des portefeuilles des clients dans un établissement financier, à savoir éviter à ce que des portefeuilles soient profitables au détriment du reste des portefeuilles.

Problématique de conception des portefeuilles Étant donné un ensemble de portefeuilles appartenant à des clients, l’établissement financier est en charge d’affecter à ces portefeuilles un ensemble d’actifs 1 d’une façon fiable, c’est-à-dire en minimisant le risque de perte, et en maximisant le gain. Mettre les meilleurs actifs dans un sous-ensemble de portefeuilles exposerait le reste des portefeuilles aux actifs risqués, et affecter des actifs appartenant au même secteur à un portefeuille augmente le risque de perte. Par conséquent, la solution consisterait donc à trouver une solution de compromis et d’équilibre entre les affectations des actifs aux différents portefeuilles. En d’autres termes, il est nécessaire de partager entre tous les portefeuilles, et d’une façon équitable, les actifs gagnants, et les actifs risqués. Différents modèles de gestion de portefeuilles ont été proposés dans la littérature, comme par exemple le modèle CDO (Collateralized Debt Obligation). Un CDO est un portefeuille qui est divisé en tranches d’actifs. Dans un modèle CDO2 , chaque portefeuille est composé d’un ensemble de tranches de portefeuilles CDO. La problématique complexe de l’affectation des tranches des actifs aux portefeuilles des clients, est une problématique fortement combinatoire. La résolution de ce problème combinatoire, non seulement permet un traitement équitable entre les clients, elle permet aussi de se libérer d’une mauvaise estimation du niveau de risque d’un actif. En effet, même si une tranche d’un actif très risqué est affectée à un portefeuille, la contrainte d’équité garantit que ce portefeuille contiendra un tas d’autres actifs de natures différentes. De nombreux modèles d’affectation des portefeuilles existent dans la littérature. Nous utilisons dans ce mémoire le modèle noté (P D) (Portfolio Design) proposé par (Flener et al., 2007). Ce modèle est fortement combinatoire, car il comprend de nom1. Un actif est une source financière qui est susceptible de produire des revenus et/ou des gains, en contrepartie d’une certaine prise de risque.

9

breuses contraintes quadratiques. Sa résolution est un véritable défi aux méthodes courantes de résolution de contraintes. En optimisation combinatoire, les méthodes exactes (complètes) et les méthodes approchées (incomplètes) représentent les deux grandes approches qui ont des stratégies différentes. Les méthodes complètes énumère d’une façon efficace et complète l’espace de recherche pour trouver les solutions. Cependant, le temps nécessaire pour assurer la complétude peut être prohibitif. D’où l’avènement des méthodes approchées qui parcourent partiellement mais intelligemment l’espace de recherche afin de résoudre le problème, sans pour autant garantir constamment le succès. Flener et al. ont signalé la nature fortement combinatoire de la recherche de la solution du problème (P D). En effet, ce problème n’a pu être résolu que sur des instances petites des CDO2 . Pour appréhender les grandes instances, ils ont aussi proposé une stratégie de décomposition du problème afin de ramener les grandes instances du problème à de petites instances, notamment en exploitant une forme de cassure de symétrie. En somme, d’un point de vue algorithmique, l’approche de Flener et al. appliquée sur les grandes instances permet de trouver une solution pour une décomposition donnée. Mais dans le cas où l’approche ne parvienne pas à trouver une solution, on ne peut rien statuer sur la consistance du problème, car il est probable qu’il existe une autre décomposition qui pourrait mener vers une solution.

Contributions Dès lors que l’approche de Flener et al. n’explore pas toutes les décompositions, la méthode proposée est évidemment incomplète, et reflète le comportement des approches incomplètes. C’est la raison pour laquelle, nous proposons en premier lieu, de faire appel directement aux approches incomplètes de recherche locale. Nous voulons voir dans quelle mesure une recherche locale avec son caractère glouton pourrait être performante. En effet, nous avons particulièrement travaillé sur l’application de différentes méthodes approchées, à savoir les méthodes locales simples, deux méthodes à voisinage variable et une méthode à population. Le critère majeur dans nos choix des recherches locales s’est porté sur les méthodes nécessitant un paramétrage simple. Pour faire fonctionner nos recherches locales, nous avons transformé le problème de satisfaction de contraintes, en un problème d’optimisation où la fonction objectif consiste à minimiser le nombre de contraintes non-satisfaites. Nous avons proposé deux fonctions de voisinage qui tiendraient compte de la sémantique bien particulière des contraintes du problème traité. La mise en œuvre a été faite sous l’environnement INCOP. Les résultats expérimentaux ont montré que nos démarches locales, notamment celles utilisant le récuit-simulé, sont très efficaces en pratique, notamment sur de grandes instances. En sommes, nous avons proposé les méthodes locales suivantes : Les méthodes locales simples : à savoir le recuit simulé, la recherche tabou et la méthode IDW (Intensification Diversification Walk). Dans la démarche naïve, nous avons exploité ces méthodes en démarrant d’une solution initiale générée aléatoirement. Cette démarche naïve n’a pas permis de converger souvent rapidement à la solution optimale. En conséquence, nous avons mis en œuvre un 10

algorithme glouton pour générer une solution initiale de bonne qualité. Ceci nous a permis d’améliorer les résultats obtenus auparavant en temps d’exécution et en qualité des portefeuilles obtenus. Les méthodes à voisinage variable : VNS (Varibale Neighbourhood Search) et SVNS (Skiewed VNS). Le choix de ce type d’approches est venu après une analyse de l’échec des méthodes locales simples à résoudre certaines instances. Ce qui a révélé deux types de paysages : neutre ou rugueux, qui imposent un changement sur les paramètres des méthodes appliquées et une variation dans le voisinage. Faire appel à une méthode qui change systématiquement de voisinage suite à un échec (e.g. VNS et SVNS), s’est avéré porteur pour améliorer les performances. La méthode à population GWW : (Go With the Winners) propose la stratégie puissante qui consiste à lancer une méthode locale à partir de nombreuses configurations différentes, tout en faisant coopérer intelligemment ces différents lancements. La recherche locale utilisée par GWW est un paramètre direct, permettant ainsi de pouvoir expérimenter facilement la panoplie des recherches locales existantes dans la littérature. Le point clé de notre recours à la méthode à population GWW est son paramétrage très simple, contrairement aux autres méthodes à population (e.g. algorithmes génétiques, colonies de fourmis, etc.) qui nécessitent un paramétrage très laborieux. Le problème (P D) est un problème qui contient beaucoup de symétries. Le modèle initial proposé par Flenet et al. est posé dans un formalisme ensembliste où les variables sont individuelles et posaient des difficultés pour exprimer les symétries. Justement, dans notre proposition d’un modèle en 0-1, les variables sont toutes regroupées dans une seule variable matricielle, où les différentes symétries du problème s’expriment d’une façon immédiate et simple. Ces caractéristiques importantes de notre modèle matriciel, est un gage intéressant pour tenter d’appliquer les méthodes complètes. Programmation Linéaire en Nombres Entiers (PLNE) : Vue la forme matricielle de la variable du problème, la linéarité d’une partie des contraintes, et une proposition de linéarisation de la partie quadratique, nous avons réussi à modéliser notre problème sous forme d’un Programme Linéaire en Nombres Entiers (PLNE) en 0-1. Les résultats expérimentaux de ce premier modèle se sont avérés modestes. L’élimination des symétries dans ce modèle nous a permis d’améliorer légèrement les performances, sans pour autant atteindre les performances des méthodes locales. Programmation Par Contraintes (PPC) : Par ailleurs, nous nous sommes investis dans une approche complète en exploitant la Programmation Par Contraintes (PPC) où les techniques d’élimination de symétries ont eu beaucoup de succès. Notre modèle PPC sans élimination des symétries s’est avéré nettement meilleur expérimentalement que le modèle PLNE. L’intégration des symétries a permis d’accélérer les performances du modèle PPC.

Plan de la thèse Le mémoire est organisé comme suit. Nous commençons par une partie d’état de l’art, composée de deux chapitres : 11

– Le chapitre 2 introduit les notions de base de notre problématique, à savoir l’optimisation des portefeuilles financiers et sa modélisation sous forme d’un problème de satisfaction de contraintes. – Le chapitre 3 fait l’état de l’art des différentes techniques, incomplètes et complètes, exploitées dans nos travaux. La partie contribution regroupe deux chapitres : – Le chapitre 4 porte sur les travaux réalisés sur les méthodes incomplètes. Les fonctions de voisinage et la fonction coût sont exposées. Puis, nous avons détaillé les algorithmes adaptés sur notre problématique. Les résultats expérimentaux réalisés sous l’environnement INCOP sont introduits et analysés. – Le chapitre 5 concerne les techniques complètes, à savoir la PLNE et la PPC. Nous avons détaillé la linéarisation du modèle. Puis, la majeure partie du chapitre aborde la question essentielle d’élimination des symétries. La fin de ce chapitre est consacrée à l’étude expérimentale des résultats sous l’environnement SCIP pour la PLNE, et l’environnement Gecode pour la PPC. Finalement, nous concluons ce mémoire en dressant les perspectives immédiates des démarches proposées.

12

Première partie

Etat de l’art

13

Chapitre 1

Ingénierie des finances et la problématique de conception des portefeuilles 1.1

Introduction

L’ingénierie des finances est une discipline de la finance qui s’intéresse à l’optimisation des montages de financements complexes, notamment dans l’objectif de faire des investissements. Parmi ses tâches, on peut citer : – combiner des instruments financiers variés, – faire appel à de nombreux établissements financiers différents, – accorder une attention particulière tant à la limitation des risques financiers qu’à l’optimisation de la rentabilité. Le rôle principal de l’ingénieur en finance est d’aider les responsables d’établissements bancaires ou financiers à gérer les risques liés aux fluctuations des marchés. Pour ce faire : – il suit, modélise et analyse l’évolution des marchés, – il évalue les prix de produits financiers complexes, la rentabilité et les risques qu’ils génèrent. Il est responsable du montage d’opérations financières de grande envergure (e.g., introduction en bourse, augmentation de capital, etc.) pour le compte de son employeur ou des clients de celui-ci. Les opérations financières ont deux enjeux majeurs : la rentabilité et le risque. Toute opération financière vise à maximiser sa rentabilité et donc son bénéfice net, tout en minimisant ses risques d’échec. Ce sont ces deux aspects opposés rentabilité/risque qui sont au coeur de la difficulté des montages financiers. En pratique, une rentabilité accrue se fait souvent en prenant des risques importants. En contre partie, une rentabilité modeste est souvent atteinte avec peu de risque. Ainsi, par exemple, la commercialisation d’une entreprise d’un nouveau produit peut générer de très gros bénéfices si le produit est bien accueilli par les consommateurs, en raison du monopole de cette entreprise sur ce produit ; d’autre part, l’entreprise en question peut endosser d’énormes pertes si le produit est mal perçu. Par contre, si l’entreprise fabrique un produit apprécié qui est déjà commercialisé par d’autres entreprises, elle obtiendra des bénéfices réduits par la concurrence. 15

De nombreux types de montages financiers existent dans le monde de la finance, mais celui qui nous semble parmi les plus complexes et les plus utilisés, est celui adoptant l’architecture CDO2 introduite dans la section 1.4. Le modèle mathématique d’optimisation relatif au CDO2 , que nous avons étudié, est introduit dans la section 1.5. Le lecteur intéressé seulement par la compréhension de la formulation mathématique abordée par nos contributions, peut entamer directement la section 1.5. Le lecteur intéressé par l’origine financière du modèle étudié est invité à aborder les sections 1.2, 1.3 et 1.4, où sont exposées respectivement les notions de base des finances, les risques financiers, et les montages CDOs.

1.2

Terminologie financière de base

Commençons par introduire les définitions financières 1 de base qui font partie du jargon quotidien des banques et des entreprises. Crédit : C’est une mise à disposition d’un prêt entre un créancier (prêteur) et un débiteur (emprunteur). Créance : Elle désigne le droit pour le créancier (prêteur) d’exiger du débiteur la remise de cette somme d’argent. Débiteur : C’est une personne, physique ou morale, qui est redevable envers une autre personne, physique ou morale, d’une somme d’argent ou d’une autre forme de créance. Dette : C’est une prestation de somme d’argent due par un débiteur à un créancier (dit aussi prêteur) . Liquidité : La liquidité mesure la capacité d’un débiteur à rembourser ses dettes dans le cas de la poursuite de ses activités. D’autre part, la solvabilité se place dans le cas de cessation des activités. Emetteur : Les émetteurs sont les agents, publics ou privés, à la recherche de ressources destinées à financer leurs investissements. Titre : Un titre financier est défini par une suite de flux de trésorerie qui sont plus ou moins risqués. Il est aussi représentatif d’une partie du capital d’une société (actions) ou d’une partie de sa dette (titres de créances). Obligation : Une obligation est un titre de créance (ou de dette). Titrisation : On appelle titrisation la technique de gestion qui consiste à créer une société (appelé Special Purpose Vehicle - SPV) qui va : (1) acheter un ensemble de créances peu liquides ; (2) émettre d’autres créances à des investisseurs. La titrisation présente un intérêt pour les banques puisqu’elle leur permet de transférer leur excès de risque de crédit à des investisseurs, de la même manière que les particuliers transfèrent le risque de sinistre aux compagnies d’assurances. Actif : Un actif est une source financière qui est susceptible de produire des revenus et/ou des gains, en contrepartie d’une certaine prise de risque. 1. Vu l’universalité des définitions, on s’est inspiré des sites financiers notamment http: //www.trader-finance.fr/lexique-finance.html, http://www.lesechos.fr/finance-marches/ vernimmen/index.php, ou généralistes comme http://fr.wikipedia.org.

16

Portefeuille financier : Un portefeuille désigne un ensemble d’actifs financiers détenus par un établissement ou un individu. Une caractéristique essentielle d’un portefeuille est son niveau de diversification permettant d’atteindre un compromis entre le risque et la rentabilité en prenant en compte la durée prévue de la détention des actifs. CDO (Collateralized Debt Obligation) : Dit aussi obligation adossée à des actifs, en français. Les CDOs sont des produits structurés venant des crédits, composés d’un portefeuille d’actifs relatif à un emprunt. Ces actifs sont divisés en diverses tranches. Pour plus de détails, voir la section 1.4.

1.3

Risque financier

Les institutions financières sont affrontées à différents risques relevant des grandes catégories citées ci-dessous (Duffie et Singleton, 2003; Optra, 2006; Godlewski et al., 2010) : Le risque du marché : Ce risque est lié aux changements imprévus des prix et des taux de change. Le risque de crédit : C’est le risque de perte en cas de l’évolution de la qualité de signature de l’émetteur (Kurtz et Pignard, 2004). Le risque de liquidité : La liquidité d’un instrument financier joue un rôle essentiel dans l’hypothèse de détention par une banque de ce dernier et donc dans l’appréciation du niveau de couverture par des fonds propres dont il doit faire l’objet. Par conséquent, le risque de liquidité se manifeste dans le cas où les coûts d’ajustement des positions financières augmentera sensiblement ou qu’une entreprise perdra l’accès au financement. Le risque opérationnel : C’est le risque de fraude, de failles systèmes, d’erreurs de négociation (e.g., mauvaise évaluation sur une affaire), et de nombreux autres risques organisationnels internes. Le risque systémique : Une crise systémique implique une crise financière système, en d’autres termes une crise qui peut toucher à de nombreux secteurs à l’échelle mondiale, ce qui peut entraîner des entreprises en faillites, puis un effondrement du système financier mondial. Les risques réglementaires et juridiques : C’est le risque que des changements dans la réglementation, des normes comptables, des codes des impôts, ou l’application d’un changement réglementaire ou juridique d’une manière imprévue. Ce qui peut entraîner des pertes imprévues ou un manque de flexibilité.

1.4

Obligations adossées à des actifs (CDO)

Le CDO est un type de portefeuille financier, qui est divisé en tranches d’actifs. Chaque tranche est caractérisée par un point d’attachement et un point de détachement ; le point d’attachement définit le minimum permis de pertes et le point de détachement le maximum permis des pertes. La tranche est bien conçue dans le cas où les pertes estimées sont comprises entre le point d’attachement et le point de détachement. Le CDO (Tavakoli, 2008) est créé depuis que l’institution financière est susceptible d’avoir de nombreux niveaux de risques liés au différentes parties d’une 17

opération financière. En se basant sur une analyse de risque, l’actif est divisé en différents groupements appelés tranches, qui sont vendus à des investisseurs. Il existe trois types de tranches (Hager, 2008), qui désignent le niveau de préférence (ou priorité de payement) : Senior, Mezzanine (ou Junior) et Equity ; ces types sont définis comme suit : si les actifs d’un CDO commencent à se détériorer, les pertes sont supportées d’abord par les tranches equity, puis par les tranches junior/mezzanine, et finalement par les tranches senior. Soit le CDO illustré dans la figure 1.1 (Ashwani, 2007), où une institution financière a un portefeuille de type CDO pour 100 $ de rendements et 7% de bénéfice. Le portefeuille est divisé en tranches : 1. Tranche A, senior, 75 $, notée AAA, 5.51% de bénéfice. 2. Tranche B, junior, 10 $, notée AA, 5.81% de bénéfice. 3. Tranche C, junior, 5 $, notée A, 7.20% de bénéfice. 4. Tranche D, junior, 5 $, notée BBB, 9.00% de bénéfice. 5. Tranche E, equity, 5 $, non notée, 29.55% de bénéfice. (5.51%75 + 5.81%10 + 7.20%5 + 9.00%5 + 29.55%5 = 7 $)

Figure 1.1 – Exemple de la structure d’un CDO

Nous remarquons que E est la plus attractive, puis D, C, B, et A. Mais, d’un autre côté, les bénéfices et le capital sont payés de manière séquentielle, commençant par la tranche senior et se terminant par la tranche equity. La tranche A est la seule à être payée, puis la tranche B, et ainsi de suite, jusqu’à la tranche E. En outre, si les pertes atteignent moins de 5 $, seulement la tranche E sera affectée. Si les pertes sont entre 5 $ et 25 $, les tranches junior sont aussi affectées, sans que la tranche senior le soit. En fait, si les pertes dépassent 25 $, la tranche senior est affectée. Pour l’instant, si seulement 90 $ vont être payés, la tranche A fait 75 $, la tranche B 10 $, la tranche C 5 $, et finalement rien pour les tranches D+E. En effet, les CDOs sont une innovation financière qui offre plus de liquidité en économie, en permettant aux institutions financières de vendre leurs produits financiers par tranches. 1.4.1

CDO2

Le CDO2 (Gilkes et Drexler, 2003) ou CDO-carré, est un type de CDO, dont le portefeuille sous-jacent est investi dans des tranches d’autres CDOs. Dans (Guillaume et al., 2008), le CDO2 est défini comme suit : 18

Définition 1.4.1 Un CDO2 est une structure à double niveaux, soutenue par un portefeuille de CDOs. Un CDO2 référence un portefeuille appelé CDO maître (master CDO, ou "outer CDO" en anglais) composé de tranches de CDOs appelées CDOs sous-jacents ("inner CDO", en anglais). La figure 1.2 (Whetten et Adelson, 2005) illustre le CDO2 ayant une structure avec deux couches d’actifs. Le premier niveau représente le CDO-maître, qui comporte des tranches de CDOs sous-jacents.

Figure 1.2 – La structure typique d’un CDO

1.4.2

Optimisation d’un portefeuille financier et le CDO2

Le CDO2 est caractérisé par les CDOs structurés en tranches (Figure 1.3), dont chacune est désignée par un point d’attachement et un point de détachement. Le payement des bénéfices, la perte au niveau des tranches et l’échéance venant de toutes les tranches concernées sont accumulés et attribués aux différentes tranches du CDO2 suivant les règles de priorités (voir le début de la section 1.4).

Figure 1.3 – Exemple d’une structure de CDO2 (Bhatt et al., 2005)

La manipulation des CDO2 , dans l’ingénierie des finances, est un problème plus compliqué qu’un CDO simple (avec un seul niveau). Mais, l’utilisation des struc19

tures à double couches est justifiée par de nombreuses raisons (Whetten et Adelson, 2005)(Guillaume et al., 2008). Parmi ces raisons, on peut évoquer le niveau de diversification plus élevé en intégrant de nombreux CDOs sous-jacents. Dans la plupart des CDO2 , des opérations financières peuvent référencer de nombreux CDOs sousjacents. On dit qu’il y a chevauchement entre ces opérations. Un chevauchement important entre ces opérations implique immédiatement un partage de risques important. En conséquence, le chevauchement dans un portefeuille CDO2 doit être minimisé. C’est un critère crucial pour minimiser le profil du risque dans un CDO2 . Supposons que le master CDO est composé de N CDOs sous-jacents incluant au c maximum M actifs financiers. Par construction, nous avons un chevauchement βi,j de deux sous-CDOs i et j au niveau d’un actif c, qu’on peut décrire comme suit :

c βi,j

  0 si l’actif c n’appartient pas à la fois au ime CDO sous-jacent et le j me CDO sous-jacent =  1 sinon

(1.1)

c ∀i, j ∈ 1..N, c ∈ 1..M, βi,j ∈ {0, 1}

Le but principal de notre travail est la minimisation du taux de chevauchement général pour chaque actif c, dans le problème CDO2 considéré, à travers le modèle mathématique (P D) qu’on va introduire dans la section suivante.

1.5

Modèles ensemblistes de conception des portefeuilles

Différents travaux ont été réalisés pour appréhender le problème de l’optimisation des portefeuilles financiers, mais ils ont la particularité de traiter le problème de point de vue ingénierie des finances avec des visions particulières et partielles. Dans (Flener et al., 2007), ils ont proposé un modèle ensembliste représentant une vision plus globale du problème d’optimisation des portefeuilles financiers puis celui de conception des portefeuilles financiers. Dans cette section nous détaillerons les deux problèmes, leurs modélisations et les différentes approches proposées dans Flener et al. 1.5.1

Modèle d’optimisation des portefeuilles (OP D)

Un (OP D) (Optimized Portfolio Design) (Flener et al., 2007) est un modèle qui décrit les relations existantes entre les différentes tranches du CDO2 . On considère, dans notre cas, que le portefeuille doit contenir v tranches et chaque tranche comporte r actifs. Au niveau de chaque tranche, les actifs doivent être choisis de telle sorte que le nombre des actifs partagés par toute paire de tranches ne doit pas dépasser λ actifs. Ici on parle du chevauchement ou d’overlapping. L’univers des actifs est de la taille 250 ≤ b ≤ 500. Un portefeuille typique est contraint par 4 ≤ v ≤ 25 tranches, dont chacune est de taille r ≈ 100. La définition 1.5.1 suivante, donnée par (Flener et al., 2007), dresse le modèle d’affectation (P D) modélisant formellement l’optimisation d’un montage CDO2 . Définition 1.5.1 (Optimized Portfolio Design : OPD) Soit V = {1, ..., v} un ensemble de v tranches. Soit B = {1, ..., b} un ensemble de b actifs. 20

Un modèle de portefeuille (OPD)hv, b, ri, est composé de v ensembles V1 , ..., Vv dits tranches (co-blocks), et de b ensembles B1 , ..., Bb dits portefeuilles (blocks). Nous avons deux contraintes : Contrainte ligne Chaque tranche contient exactement r actifs ∀i ∈ V :| Vi |= r. Contrainte de chevauchement ou colonne Dite condition d’équilibre, chaque paire de tranches présente au maximum λ éléments en commun. On désigne λ l’overlap maximum. ∀i 6= j ∈ V :| Vi ∩ Vj |≤ λ. En somme, nous obtenons le modèle global (OP D) ci-dessous où on voudrait minimiser le degré de chevauchement :   min λ    ∀j ∈ B : Bj ⊆ V    ∀i ∈ V : Vi ⊆ B (1.2) OP Dhv, b, ri ∀j ∈ B :| Bj |≤ v     ∀i ∈ V :| Vi |= r    ∀i 6= j ∈ V :| V ∩ V |≤ λ i j Pour faire le parallèle avec un montage CDO2 , chaque tranche Vi est prise des CDOs sous-jacents, et chaque portefeuille Bi composera le CDO maitre. L’objectif du modèle (OP D) est de concevoir les portefeuilles du CDO maitre assurant un haut degré de diversification. Notons que les valeurs des coupons d’attachement et de d’attachement relatives aux CDOs manipulés ne sont pas pris en compte dans notre modèle. En fait, ces valeurs sont intimement liées au comportement des actifs, et doivent provenir d’une expertise de l’historique de ces actifs : un travail pointu et difficile qui relève de la finance et des statistiques. Cependant, une fois ces valeurs proposées, reste la problématique complexe de l’affectation des tranches des actifs aux portefeuilles modélisé dans la formulation (1.2) : une problématique fortement combinatoire. La résolution de ce problème combinatoire, non seulement permet un traitement équitable entre les clients, elle permet aussi de se libérer d’une mauvaise estimation du niveau de risque d’un actif. En effet, même si une tranche d’un actif très risqué est affectée à un portefeuille : la contrainte de chevauchement force à ce que ce portefeuille partage le moins d’actifs entre la tranche risquée et les autres tranches qui le composent, évitant ainsi l’effondrement de nombreux portefeuilles suite à la défaillance d’un actif. En d’autres termes, en assurant un haut degré de diversification entre les portefeuilles, on garantit aussi un partage équitable des risques et des gains. 1.5.2

Modèle de conception des portefeuilles (P D)

Dans (Flener et al., 2007), Flener et al. ont réussi à calculer analytiquement une borne inférieure de λ, donnée par l’inéquation (1.3). λ≥

d rvb e2 mod(rv, b) + b rvb c2 (b − mod(rv, b)) − rv v(v − 1) 21

(1.3)

Flener et al. ont montré que la borne inférieure (1.3) est de piètre qualité quand la taille est grande. On remplace λ par cette borne ou une autre valeur constante dans la dernière contrainte du modèle mathématique (1.2), et on élimine la fonction objectif, donnant le modèle (1.4).   ∀j ∈ B : Bj ⊆ V    ∀i ∈ V : Vi ⊆ B  ∀j ∈ B :| Bj |≤ v (1.4) P Dhv, b, r, λi   ∀i ∈ V :| V |= r  i   ∀i 6= j ∈ V :| V ∩ V |≤ λ i j Le problème (1.4) à résoudre est bien évidemment un problème de satisfaction de contraintes. Dans la suite du document, ce modèle (P D) est dit problème de conception des portefeuilles (portfolio design). Le modèle (P D) consiste à concevoir les portefeuilles du CDO maitre à partir des tranches des CDOs sous-jacents. Mais au fait, ce modèle est plus général et peut être exploité pour modéliser un tas de situations où on veut exprimer un haut niveau de diversification. Soit par exemple une chaine de b magasins appartenant à la même enseigne commerciale. On dispose de v types de produits. On voudrait alimenter les b magasins avec les v types de produits en s’assurant que : – On alimente l’ensemble de tous les magasins avec exactement r unités de chaque type de produits. – Les magasins soient différents, diversifiant leurs contenances. Cet exemple modélise la diversification au niveau des types de produits. On pourrait poser le même modèle en diversifiant les coûts des produits. 1.5.3

Résolution du problème (P D)

En fait, Flener et al. ont constaté une ressemblance entre le problème (P D) et un autre problème pleinement étudié en optimisation combinatoire, le problème (BIBD) (Marshall Hall, 1964)(Balanced Incomplete Block Designs) qui est défini comme suit :   ∀j ∈ 1..b, Bj ⊆ V    ∀i ∈ 1..v, Vi ⊆ B  ∀j ∈ 1..b, | Bj |= k BIBDhv, b, r, λ, ki (1.5)   ∀i ∈ 1..v, | V |= r  i   ∀i 6= j ∈ 1..v, | V ∩ V |= λ i j En programmation par contraintes, (BIBD) est un problème qui a été bien appréhendé, y compris sur les grandes instances. Ceci en exploitant les différentes techniques de cassure de symétries (voir la section 2.3.2). Flener et al. (Flener et al., 2007) proposent une approche de résolution après un passage du problème (P D) vers un problème (BIBD) en calculant la valeur du paramètre k. Leur deuxième proposition consiste à décomposer les grandes instances en m + 1 petites instances. Pour le problème P D < v, b, r, λ >, nous obtenons la décomposition suivante : P Dhv, b, r, λi = m × P Dhv, b1 , r1 , λ1 i + P Dhv, b2 , r2 , λ2 i. 22

(1.6)

Cette décomposition doit respecter certaines conditions : – 0 ≤ ri ≤ bi ≥ 1 for i = 1, 2. – b = mb1 + b2 – r = mr1 + r2 – λ ≤ λ1 + λ2 Pour plus de détails, voir (Flener et al., 2004, 2007).

1.6

Conclusion

Dans ce chapitre, nous avons introduit quelques notions de base de l’ingénierie des finances, à savoir : – la problématique générale de l’ingénierie des fiances et la recherche du compromis risque versus rentabilité, – le modèle des montages financiers CDO et CDO2 , – le modèle ensembliste général de Flener et al. pour appréhender le compromis risque versus rentabilité. Nous avons introduit le modèle ensembliste de Flener et al. pour l’optimisation des portefeuilles, noté (OP D), ainsi que sa variante en satisfaction de contraintes (P D). C’est un modèle dédié aux portefeuilles de type CDO2 , mais suffisamment général pour traiter des problèmes de la recherche d’un compromis entre la prise de risques et la rentabilité. Le chapitre suivant abordera un état de l’art des méthodes d’optimisation dont nous allons nous servir dans nos contributions dans la résolution du problème (P D) avec des démarches incomplètes et des démarches complètes.

23

24

Chapitre 2

Méthodes de résolution 2.1

Introduction

Ce chapitre présente les méthodes et les outils de modélisation et de résolution, dont nous allons nous servir dans nos approches de résolution du problème de conception des portefeuilles (P D). Nous rappelons les méthodes d’optimisation locale, à savoir les méthodes locales simples (e.g., recuit-simulé, IDWalk, recherche tabou), les méthodes à voisinage variable (e.g., VNS et SVNS)et la méthode à population GWW. Ces méthodes locales seront utilisées pour obtenir rapidement des solutions au détriment de leur optimalité. Enfin, nous détaillons les méthodes complètes par programmation par contraintes, et par programmation linéaire. Ces méthodes complètes seront exploitées pour garantir l’obtention d’une solution au détriment du temps d’exécution qui est de nature exponentielle.

2.2

Méthodes locales

Dans cette section, nous décrivons les méthodes approchées, à savoir les méthodes de recherche locale simple (e.g. recuit simulé, IDWalk et tabou), les méthodes à voisinage variable (e.g. VNS et SVNS) et une méthode à population (e.g. GWW). 2.2.1

Méthodes de recherche locale simple

Le problème de conception des portefeuilles est un problème classé difficile. Vu son aspect combinatoire, les méthodes approchées (ou locales) sont recommandées pour obtenir une bonne solution en un temps efficace. Dans cette section nous décrirons les différents types de méthodes locales prises en considération dans nos travaux. 2.2.1.1

Recuit simulé

Le recuit simulé (Kirkpatrick et al., 1983b) est une méthode proposée par Kirkpatrick et al. en s’inspirant du domaine de la métallurgie. Elle est caractérisée par la température T qui est une mesure importante dans le refroidissement du métal. On peut définir les étapes de cette méthode comme suit : 25

1. Commencer par une solution initiale S0 , dont l’évaluation est f (S0 ). 2. Choisir une nouvelle solution aléatoire S1 dans le voisinage de S0 noté par V (S0 ). (a) si f (S0 ) ≥ f (S1 ) (problème de minimisation) alors S1 est adoptée tout en améliorant la solution courante S0 . f (S1 )−f (S0 )

T . On choisit aléatoirement (b) si (f (S0 ) < f (S1 )) on calcule v = e− une valeur p dans [0, 1]. Si p ≤ v alors S0 est remplacée par S1 . 3. T est décrémentée lentement à chaque itération. 4. si T <  alors l’algorithme est arrêté, avec S0 meilleure solution trouvée sinon aller à l’étape 2. L’algorithme 1 reproduit les étapes algorithmiques de la méthode du recuit simulé.

Algorithm 1 Recuit Simulé Input: S0 solution initiale ; k ∈ ]0, 1[ paramètre de refroidissement ;  seuil fixé, proche de 0 ; T température ; M axIter nombre maximal d’itérations 1: Iter ← 0 2: Choisir au hasard une solution initiale S0 3: repeat 4: Iter ← Iter + 1 5: Choisir au hasard une solution S1 dans V (S0 ) 6: δf = f (S1 ) − f (S0 ) 7: if δf ≤ 0 then 8: S0 ← S1 9: else 10: Tirer au hasard p dans [0, 1] 11: if p ≤ e−(δf /T ) then 12: S0 ← S1 13: end if 14: end if 15: T ←k×T 16: until (T ≤ ) ou (Iter = M axIter) 17: return S0 2.2.1.2

Méthode IDWalk

La méthode IDWalk (Intensification and Diversification Walk) (Neveu et al., 2004) a été introduite pour offrir une meilleur efficacité en utilisant peu de paramètres. L’algorithme 2 détaille les étapes de IDWalk. Elle nécessite seulement deux paramètres : – M N : le nombre de voisins maximal à couvrir, – SN (spare neighbor) : le type de la remontée. Considérant CS la solution courante et BS la meilleure solution. La méthode procède en deux étapes : – Intensification : les M N voisins de la solution courante sont explorées. On choisit le meilleur voisin CN . Si CN est meilleure que BN alors BS est remplacée par CN . 26

– Diversification : si BN n’améliore pas CS alors on choisit la meilleure solution dans les SN premiers voisins. Dans le cas où SN = 1 on choisit aléatoirement une solution parmi l’ensemble des voisins. A chaque étape, si la nouvelle solution CS améliore la meilleure solution BS alors BS est remplacé par CS. Algorithm 2 IDWalk Input: S nombre de mouvements, M ax nombre de voisins ; SP type de diversification 1: Calculer une solution initiale aléatoire x 2: xopt ← x 3: for i ∈ 1..S do 4: N bSol ← 1 ; Solrejete ← φ ; SolAccepte ← f alse 5: while (N bSol ≤ M ax) et (SolAccepte = f alse) do 6: Choisir une solution x0 ∈ V (x) 7: if f (x0 ) ≤ f (x) then 8: SolAccepte ← true 9: else 10: Solrejete ← Solrejete ∪ {x0 } 11: end if 12: N bSol ← N bSol + 1 13: end while 14: if SolAccepte then 15: x ← x0 16: else 17: if SP 6= 0 then 18: x ← Select(Solrejete , SP ) 19: end if 20: end if 21: if f (x) < f (xopt ) then 22: xopt ← x 23: end if 24: end for 25: return xopt 26: procedure Select(Solrejete , SP ) 27: if SP = 1 then 28: Choisir aléatoirement une solution x0 ∈ Solrejete 29: else 30: Choisir la meilleure solution x0 dans les SP premiers candidats dans Solrejete 31: end if 32: Return x0 33: end procedure

2.2.1.3

Recherche Tabou

La méthode tabou (Algorithme 3) a été introduite par Glover (Glover et Laguna, 1997). Elle est caractérisée par la liste tabou T , qui contient les solutions tabou. Dans une recherche tabou, nous commençons par une solution initiale x et on cherche la meilleure solution x0 dans les voisins V (x) de x et qui ne figure pas dans T . On met 27

à jour la meilleure solution si x0 est meilleure que la solution optimale courante. On s’arrête quand la liste est pleine ou quand la condition d’arrêt est vérifiée. On peut adopter d’autres conditions d’arrêt (voir par exemple (Prins, 1994)). Algorithm 3 Tabou Input: x solution initiale ; T la liste tabou ; V (x) le voisinage de x ; xopt la meilleure solution. 1: T ← φ 2: LT ← 0 3: Calculer une solution initiale aléatoire x 4: xopt ← x 5: while condition d’arrêt non atteinte do 6: Soit la configuration x0 ∈ V (x) tel que ∀x00 ∈ V (x), f (x0 ) ≤ f (x00 ) et x00 6∈ T (et éventuellement critère d’aspiration). 7: if f (x0 ) < f (xopt ) then 8: xopt = x0 9: end if 10: Mettre à jour la liste T avec l’élément x0 11: x = x0 12: end while 13: return xopt

2.2.2

Méthode de recherche locale à voisinage variable (VNS)

La Recherche à Voisinage Variable RV V (Variable Neighborhood Search V N S) (Mladenovic et Hansen, 1997) est une méta-heuristique récente, ou une plate-forme pour construire des heuristiques, tout en exploitant systématiquement le principe de changement de voisinages, dans la décente à l’optimum local et pour sortir de la vallée qui la contienne. La méthode VNS est décrite par l’algorithme 4 et illustré dans la figure 2.1. Comme le montre le schéma de base de la méthode : 1. On précise en premier lieu une série de structures de voisinages, qui définissent les voisinages qui entourent tout point x ∈ X de l’espace des solutions. 2. Une recherche locale est appliquée, afin de mener vers un optimum local x. 3. Un point x0 est sélectionné aléatoirement dans le voisinage N1 (x) de x. Une descente à partir de x0 est réalisée avec une méthode de recherche locale. Ce qui mène vers un nouvel optimum local x00 . A ce niveau, trois résultats sont possibles : (a) x00 = x, i.e. la solution obtenue est encore au fond de la même vallée ; dans ce cas la procédure est réitérée en utilisant un nouveau voisinage Nk (x), k ≥ 2. (b) x” 6= x et f (x”) ≥ (x), i.e. un autre optimum local doit figurer avec le nouveau voisinage Nk(x), k>=2. (c) x00 6= x et f (x00 ) < f (x), i.e., un autre optimum local, meilleur que celui déjà obtenu ; dans ce cas, la recherche est recentrée autour de x00 et recommence avec le premier voisinage. Le dernier voisinage doit être balayé 28

sans atteindre une solution meilleure que le meilleur optimum déjà trouvé : dans ce cas, la recherche est relancée à nouveau sur le premier voisinage N1 (x) jusqu’à atteindre la condition d’arrêt (e.g. le temps maximum d’exécution ou le nombre maximum d’itérations à partir de la dernière solution adoptée).

Algorithm 4 VNS Input: x : solution initiale ; Kmax paramètre de VNS ; ls méthode locale ; 1: Calculer une solution initiale aléatoire x 2: while condition d’arrêt non atteinte do 3: k ← 1; 4: while (k ≤ Kmax ) do 5: x0 ← Shake(x, k) ; 6: x00 ← LS(x0 ) ; 7: if f (x00 ) < f (x) then 8: x ← x00 ; 9: k ← 1; 10: else 11: k ← k + 1; 12: end if 13: end while 14: end while 15: return x 16: procedure Shake(x, k) 17: Générer aléatoirement une solution x0 dans le k ème voisinage de la solution x ; return x0 ; 18: end procedure

Figure 2.1 – Illustration de la recherche VNS (Hansen et Mladenovic, 2009)

29

2.2.2.1

Méthode Skewed Varibale Neighbourhood Search (SVNS)

Généralement, la méthode VNS donne de meilleurs résutats, comparée à une recherche locale de descente (appelée multistart). VNS est bien meilleure quand le paysage des solutions représente de nombreux optima locaux. VNS a une facilité pour visiter des voisins lointains. En conséquence, il arrive que VNS se comporte pratiquement comme une méthode multistart. Justement, une nouvelle variante, dite SVNS (pour Skewed VNS), permet d’y remédier en se permettant d’intensifier la recherche sans pour autant changer de voisinage. Le schéma modifié skewed VNS (SVNS ) (Mladenovic et Hansen, 1997), ou le VNS biaisé est présenté par l’algorithme 5 SVNS. La règle de relaxation recentre la recherche en utilisant à la place de f (x00 ) une fonction linéaire d’évaluation f (x00 ) − αρ(x, x00 ) où ρ(x, x00 ) est la distance entre x et x00 et α un paramètre. La mesure de la distance entre deux solutions est pratiquement facile à calculer, e.g. la distance de Hamming quand les solutions sont définies par des vecteurs booléens ou la distance Euclidienne dans le cas de solutions continues. Algorithm 5 SVNS(rl) Input: x : solution initiale ; Kmax paramètre de VNS ; rl méthode locale ; 1: Calculer une solution initiale aléatoire initiale x 2: while condition d’arrêt non atteinte do 3: k ← 1; 4: while (k ≤ Kmax ) do 5: x0 ← Shake(x, k) ; 6: x00 ← LS(x0 ) ; 7: if f (x00 ) < f (x) then 8: x ← x00 ; 9: else 10: if f (x00 ) − αρ(x, x00 ) < f (x) then 11: x ← x00 ; 12: k ← 1; 13: else 14: k ← k + 1; 15: end if 16: end if 17: end while 18: end while

2.2.3

Méthode de recherche locale à population GWW

L’algorithme 6, GWW (Aldous et Pitman, 1994), est une méthode à population, qui explore différentes configurations en même temps dans un espace de recherche en gérant une population de particules (solutions). Au début, les particules sont distribuées aléatoirement et un seuil est fixé au-dessus de la plus mauvaise solution. A chaque itération, on diminue la valeur du seuil. Les particules dont les valeurs sont supérieures au seuil sont dites des particules mortes, sinon elles sont dites vivantes. Après la diminution du seuil, les particules mortes sont redistribuées sur les particules vivantes. 30

Algorithm 6 GW W − LS Input: B nombre de particules ; S longueur de la marche ; T paramètre seuil ; W P paramètre de la marche ; 1: Chaque particule est aléatoirement placée sur une configuration et rangée dans le tableau P articules 2: Seuil ← la particule de moindre coût dans P articules 3: while True do 4: Seuil ← baisser le seuil Seuil 5: if M eilleure(P articules) > Seuil then 6: Retourner M eilleure(P articules) 7: else 8: Redistribuer P articules en plaçant chaque particule ayant un coût supérieur à Seuil sur une particule vivante choisie aléatoirement 9: for particule p dans P articules do 10: for i ∈ 1..S do 11: déplacer la particule p dans le meilleur de ses voisins en exploitant une recherche locale de paramètre W P 12: end for 13: end for 14: end if 15: end while

Dans (Neveu et Trombettoni, 2003), la marche aléatoire a été remplacée par une méthode locale (e.g., la méthode tabou, le recuit simulé, ...). L’algorithme 6, ainsi que d’autres méthodes incomplètes ont été implémentés dans la bibliothèque INCOP (Neveu, 2005; Neveu et Trombettoni, 2004). 2.2.4

Étude des paysages

Le paysage du problème traité dépend de l’approche utilisée, de la fonction de voisinage et de la fonction d’évaluation (Marmion et al., 2013) (Jarboui et al., 2013). Il représente l’évolution des mouvements réalisés, ainsi que l’évolution des solutions trouvées, dont l’objectif est de trouver l’optimum global. L’étude d’un voisinage d’une solution ou une vallée d’un paysage, est liée à l’optimum local trouvé. L’algorithme 7 HillClimbing donne le comportement de la méthode locale dans l’étape d’intensification, avec une solution initiale qui est généralement, calculée via l’étape de diversification. Algorithm 7 HillClimbing Input: S ensemble des solutions ; V (s) ensemble des voisins de la solution s 1: Choisir une solution initiale aléatoire s ∈ S 2: repeat 3: Choisir s0 ∈ V (s) telle que eval(s0 ) < eval(s) 4: s ← s0 5: until (s est un minimum local)

La nature du paysage est distinguée par rapport à la distance qu’on peut observer entre une solution s et une autre solution s0 . Cette distance notée par dist(s, s0 ), 31

représente le nombre de mouvements nécessaires pour aller de s vers s0 . On distingue trois types de paysages (Jarboui et al., 2013) : le paysage lisse, le paysage rugueux et le paysage plat. Paysage lisse

La figure 2.2 illustre un paysage assez lisse et moins vallonné. Dans ce genre de situation selon (Jarboui et al., 2013), une métaheuristique avec une bonne capacité d’exploitation 1 doit permettre une bonne exploration du voisinage d’une solution s et atteindre l’optimum global.

Figure 2.2 – Exemple d’un paysage lisse (Marmion, 2011)

Paysage rugueux

La figure 2.3 représente un paysage assez accidenté dit rugueux. C’est un paysage qui représente un cas typique du problème des optimaux locaux posé par les approches incomplètes. Par conséquent, une bonne capacité d’exploration est recommandée (Jarboui et al., 2013), afin de permettre à la métaheristique de passer d’un voisinage vers un autre, dans le but de ne pas rester piégé au fond de l’une des vallée du paysage.

Figure 2.3 – Exemple d’un paysage rugueux (Marmion, 2011)

Paysage neutre

Le paysage neutre (Jarboui et al., 2013)(Marmion et al., 2012) est un paysage sous forme d’un plateau. Il représente le cas où aucune amélioration de la solution en cours n’est observée. Ce type de phénomène se présente lorsque la métaheuristique prend en considération les solutions neutres. Par conséquent, on obtient une suite de mouvements qui fournissent des solutions dont les évaluations sont égales. 1. Une métaheuristique avec une grande capacité d’exploitation sera alors très efficace pour se déplacer de n’importe quelle solution vers une solution de très bonne qualité voire même l’optimum global.

32

Figure 2.4 – Exemple d’un paysage neutre

On constate que la métaheuristique appliquée stagne, ce qui fait perdre du temps sans atteindre l’optimum global. Pour régler ce genre de problème (Jarboui et al., 2013), on doit appliquer une méthode avec une bonne qualité d’exploitation et une bonne qualité d’exploration.

2.3

Méthodes globales

En dépit de l’apport des méthodes locales par rapport à l’efficacité du temps d’exécution, les méthodes globales demeurent infaillible par rapport à l’optimalité de la solution calculée si elle existe. Dans cette section, nous présenterons des approches globales ; à savoir : la Programmation Linéaire en Nombres Entiers et la Programmation Par Contraintes. 2.3.1

Programmation linéaire en nombres entiers (PLNE)

La programmation linéaire (PL) est un outil de base en recherche opérationnelle. Elle comprend des techniques puissantes qui permettent de modéliser et de résoudre une multitude de problèmes d’optimisation. Résoudre les problèmes d’optimisation avec la PL consiste à chercher le minimum (resp. le maximum) d’une fonction f , tout en assurant la satisfaction d’un système d’équations et d’inéquations linéaires. La difficulté de la résolution réside dans deux points : 1. déterminer l’ensemble des points qui satisfont les contraintes, puis 2. trouver leur minimum. On distingue dans la programmation linéaire, la programmation linéaire en nombres réels (où les variables sont continues) et la programmation linéaire en nombres entiers. La programmation linéaire en nombres entiers (PLNE) 2 (Wolsey, 1998; Winston, 2004) fournit des méthodes efficaces les plus exploitées pour le traitement des problèmes d’optimisation, notamment en raison de ses possibilités riches en modélisation. Un programme PLNE est un programme linéaire (PL) où certaines variables doivent être entières, voire même restreintes au domaine booléen {0, 1}. Ces variables sont dites soumises à des contraintes d’intégrité 3 . En général, un modèle PLNE implique : – Un ensemble de variables mathématiques de décision ; – Un ensemble de contraintes linéaires, où chacune exige qu’une expression linéaire des variables de décision est soit égale à, inférieure à, ou supérieure à une valeur réelle ; 2. En anglais, Mixed-Integer Linear Programming (MILP, MIP). 3. Un problème de programmation linéaire classique (PL) sera dit en variables continues.

33

– Une fonction objectif linéaire qui évalue le coût de la solution. Résoudre un problème PLNE consiste à chercher dans l’espace des points satisfaisant toutes les contraintes, celui qui donne la plus petite valeur à la fonction objectif à minimiser. En général, un problème PLNE prend la forme : Minimize cT x Ax (≤, =, or ≥) b xi ∈ Z, i = 1..p xi ∈ R, i = p + 1..n où x représente le vecteur des variables de décision, p est une valeur entière positive, les valeurs cj , ∀j = 1, ..., n sont appelées coefficients objectifs, A est une matrice de coefficients de taille m × n, et b est un vecteur du second membre de taille m × 1 associé au système de contraintes linéaires. Pour résoudre les PLNE, nous faisons appel à la méthode de recherche arborescente par séparation et évaluation (branch-and-bound en anglais) provenant du domaine de la recherche opérationnelle. Cette méthode est essentiellement une approche “diviser-pour-régner” (divide and conquer en anglais), i.e., décomposer récursivement le problème original en sous-problèmes jusqu’à atteindre des problèmes faciles à résoudre. Pour plus de détails, nous recommandons les références (Winston, 2004; Wolsey, 1998; Papadimitriou et Steiglitz, 1998; Lawler et Wood, 1966). 2.3.2

Programmation par contraintes (PPC)

La programmation par contraintes PPC (Constraint Programming - CP en anglais) propose un paradigme de programmation déclarative, désignant en même temps un formalisme et une algorithmique puissante pour modéliser et résoudre des problèmes combinatoires (e.g., ordonnancement, planification, etc.). Elle prend ses origines dans les travaux de Laurière (Laurière, 1978), et a eu un développement important (Hentenryck, 2002; Rossi et al., 2006; Régin, 2011; Lecoutre, 2013) dans les années 1990 et 2000, en intégrant notamment des techniques de recherche opérationnelle (Régin, 2011). La PPC est basée sur la notion de réseau de contraintes, ou plus généralement de problème de satisfaction de contraintes CSP (Constraint Satisfaction Problem). Un CSP P est défini par un triplet P = hX, D, Ci où : – X est un ensemble de n variables X = {x1 , x2 , ..., xn }. – D est un ensemble de n domaines D = {D1 , D2 , ..., Dn }. D dénote le n-uplet hD1 , ..., Dn i des domaines des variables, avec Di l’ensemble les valeurs définissant la variable xi . – C est l’ensemble des t contraintes C = {c1 , c2 , ..., ct } du problème. Une contrainte cj est définie par l’ensemble de tuples autorisés R(cj ) sur une séquences de variables vars(cj ) appelée signature ou portée de la contrainte. La taille de vars(cj ) est l’arité de la contrainte cj . R(cj ) est un sous-ensemble du produit cartésien des variables de la séquence vars(cj ). Une instanciation (ou affectation) I d’un ensemble de variables V est une fonction qui met en relation chaque variable xi ∈ V une valeur v(xi ) de son domaine Di . Une solution est une instanciation complète qui satisfait toutes les contraintes ; dite aussi instanciation globalement consistante. Résoudre un CSP ou la recherche des 34

solutions d’un CSP est un problème NP-complet.L’ensemble des solutions réalisables d’un CSP est noté sol(X, D, C). La programmation par contraintes PPC propose des langages et une algorithmique générique de résolution basée sur les techniques de filtrage, de propagation, et de décomposition des problèmes de satisfaction de contraintes (Régin, 2004). Filtrage et réduction des domaines

Pour définir ce qu’est un filtrage, on commence par définir ce qu’est une consistance des domaines. Définition 2.3.1 (consistance des domaines) La consistance des domaines est liée à la notion de faisabilité d’une solution partielle. Une valeur v appartenant au domaine d’une variable xi vérifie la consistance des domaines, si et seulement si pour toute contrainte cj impliquant la variable xi , il existe une instanciation des variables appartenant à vars(c) telle que c soit vérifiée. L’algorithme de filtrage consiste à réduire les domaines des variables, en supprimant les valeurs qui n’appartiendront à aucune solution (i.e., en vérifiant la consistance des domaines). Définition 2.3.2 (Algorithme de filtrage) Un algorithme de filtrage est un algorithme de réduction associé à une contrainte cj . Son rôle est de supprimer les valeurs non consistantes 4 des domaines de définition des variables dans vars(cj ). Suite à la réduction du domaine d’une variable, d’autres variables apparaissant dans d’autres contraintes peuvent devenir inconsistantes. D’où l’intérêt de faire appel à un mécanisme de propagation pour tenter toutes les réductions possibles suite au retrait des valeurs contenues dans les domaines des variables. Exemple 2.3.3 ((Consistance des domaines)) Soit le CSP P = hX, D, Ci définit comme suit : X = {x1 , x2 } D = {0, 1, 2, 3, 4}, Dx2 = {0, 1, 2, 3} P x1 (2.1) C = {c1 } c1 : x1 < x2 Les deux domaines Dx1 et Dx2 ne sont pas consistants, du moment que : ◦ la valeur 4 de Dx1 n’est pas consistante, puisque aucune instanciation de x2 dans Dx2 ne peut vérifier la contrainte c1 , ◦ la valeur 0 de Dx2 n’est pas consistante, puisque aucune instanciation de x1 dans Dx1 ne peut vérifier la contrainte c1 . Par contre après le filtrage, on obtient les domaines Dx1 = {0, 1, 2, 3} et Dx2 = {1, 2, 3} qui vérifient la consistance des domaines (voir la définition 2.3.1). Pour plus de détails, nous renvoyons le lecteurs aux références (Rossi et al., 2006; Régin, 2011; Lecoutre, 2013) 4. Une valeur non consistante d’une variable xi est une valeur qui ne vérifie pas la consistance des domaines

35

Méthodes de résolutions des CSP

Une méthode de résolution de CSP doit identifier une affectation des valeurs aux variables de telle sorte que toutes les contraintes soient satisfaites (i.e., une affectation totale et consistante). La démarche générale consiste à explorer l’espace de recherche défini par le produit cartésien des domaines, et se termine quand une affectation consistante est trouvée, ou bien quand l’inexistence d’une telle affectation est prouvée (CSP inconsistant). La méthode la plus simple pour chercher une solution d’un CSP consiste à générer toutes les affectations "complètes" des variables, et à vérifier ensuite, si chacune des instanciations candidates générées est une solution valide du problème. Cette stratégie "generate and test" est très coûteuse. D’où l’intérêt de faire appel à des schémas élaborés plus sophistiqués pour résoudre d’une manière plus efficace le problème en question. Le premier schéma adopté est celui du "retour arrière" qui consiste à générer une affectation partielle consistante ; puis à étendre cette affectation partielle avec l’instanciation d’une nouvelle variable. En d’autres termes, les variables du CSP sont instanciées jusqu’à ce que : – Au moins une contrainte est violée. L’algorithme revient sur la dernière instanciation, et teste une autre valeur sur la variable la plus récente. – Si toutes les valeurs de cette variable ont été testées, sans succès, l’algorithme fait un retour arrière (back-track en anglais) sur la variable qui précède la variable la plus récente. – Ce processus s’arrête une fois qu’une solution est trouvée, ou bien le retour arrière atteint la racine de l’arbre de recherche sans qu’une solution ne soit trouvée. Le schéma de résolution par "retour arrière" peut être mis en œuvre dans deux directions : 1. Stratégie prospective : Elle consiste à tirer profit des algorithmes de filtrage (voir la sous-section précédente) avant chaque instanciation d’une variable, afin d’éliminer celles qui ne pourront pas mener à une solution. 2. Stratégie Rétrospective : En cas d’échec sur une variable, au lieu de revenir sur la variable précédente, on analyse les causes de l’échec pour faire un retour arrière vers la variable qui est à l’origine de l’échec. Parmi les méthodes rétrospectives les plus élaborées, on cite la méthode de dynamic-backtracking (Ginsberg, 1993). Ces deux dernières stratégies sont les plus couramment utilisées dans les solveurs de contraintes, et tout particulièrement le recours intensif aux algorithmes de filtrage permettant de réduire d’une façon drastique l’espace de recherche.

2.4

Problème symétrique

La symétrie est l’un des sujets critiques en PPC et en recherche opérationnelle, devenant un domaine de recherche à part entière. L’origine du traitement des symétries, plus spécialement en PPC, est dû au fait que le processus de la recherche des solutions peut revisiter de nombreuses fois des états équivalents, voire même un 36

nombre exponentiel de fois. Ces états équivalents sont dits symétriques. L’élimination des symétries permet de réduire l’arbre de recherche manipulé par l’algorithme de résolution. Par conséquent, les techniques d’élimination des symétries peut booster sérieusement le processus de résolution sur les problèmes symétriques. Dans notre travail, nous nous intéressons aux symétries des solutions définies sur des matrices de variables. Exemple 2.4.1 (Les symétries dans un échiquier) (Rossi et al., 2006) Considérons un échiquier 3 × 3, dont nous marquons les 9 cases avec les nombres de 1 à 9. Nous supposons que le problème admet une solution désigné par la matrice sol ci-dessous : 1 2 3 4 5 6 7 8 9 (sol) Les nombres de 1 à 9 sont des points à déplacer par des symétries. Nous considérons 9 symétries naturelles sur l’échiquier qui génèrent des solutions satisfaisant le problème. Une symétrie d’identité est une symétrie qui laisse chaque point à sa place, ce qui est représenté par l’échiquier le plus à gauche noté par id. Par la suite, nous pouvons réaliser une rotation de 90◦ , de 180◦ et de 270◦ dans le sens des aiguilles de la montre. Les emplacements des points résultant après chaque degré de rotation sont donnés par les échiquiers rot90, rot180 et rot270. Finalement, nous avons des réflexions 5 sur l’axe vertical, sur l’axe horizontal et sur les deux diagonales, illustrées respectivement par les échiquier v, h, d1 et d2. 1 2 3 4 5 6 7 8 9 id

7 4 1 8 5 2 9 6 3 rot90

9 8 7 6 5 4 3 2 1 rot180

3 6 9 2 5 8 1 4 7 rot270

3 2 6 5 9 8 v

7 8 9 4 5 6 1 2 3 h

1 4 7 2 5 8 3 6 9 d1

9 6 3 8 5 2 7 4 1 d2

1 4 7

Le lien entre ces symétries est très direct via les permutations. Chaque symétrie définit une permutation d’un ensemble de points. On illustre par les huit échiquiers ci-dessus, 5 types de symétries : symétrie d’identité, symétrie rotationnelle, symétrie colonne, symétrie ligne et symétrie diagonale. On distingue deux types de méthodes d’élimination de symétries à savoir : les méthodes statiques et les méthodes dynamiques. Il existe différentes manières pour éliminer les symétries en programmation par contraintes (Gent et Smith, 1999; Flener et al., 2002; Puget, 2006; Mears et al., 5. On appelle réflexion toute symétrie orthogonale par rapport à un hyperplan (i.e.un espace de dimension n-1).

37

2014). Généralement, elles démarrent toutes du même principe qui est d’ajouter des contraintes au CSP initial. Ces contraintes ajoutées, appelées contraintes conditionnelles doivent éliminer toutes les variantes symétriques 6 , sans éliminer des solutions non génériques. Puisque nous allons aborder dans nos contributions un modèle matriciel, nous allons mettre en avant, dans les deux sections ci-dessous, l’élimination de symétries par rapport aux matrices, dont on peut citer différents travaux (Flener et al., 2001, 2002). 2.4.1

Symétrie sémantique

Dans la PPC nous sommes intéressés par deux problèmes : – la recherche d’une solution, – la recherche de plusieurs solutions. Par conséquent, dans (Benhamou et Saïdi, 2007a), on distingue deux niveaux de symétrie sémantique : Définition 2.4.2 (Symétrie sémantique par consistance) Deux paires de variablevaleur hvi , bi i ∈ V × Di et hvj , bj i ∈ V × Dj sont symétriques par consistance si et seulement si les assertions suivantes sont équivalentes : 1. il existe une solution qui affecte la valeur bi à la variable vi ; 2. il existe une solution qui affecte la valeur bj à la variable vj ; Les paires variable-valeur peuvent représenter plus qu’une symétrie par consistance, ainsi elles peuvent être symétriques pour tout l’ensemble des solutions. Par conséquent, si sol(P ) dénote l’ensemble des solutions du CSP P , alors nous définissons le second niveau de symétrie comme suit : Définition 2.4.3 (Symétrie sémantique pour toutes les solutions) Deux paires variablevaleur hvi , bi i ∈ V × Di et hvj , bj i ∈ V × Dj sont symétriques pour sol(P ) si et seulement si pour chaque solution affectant la valeur bi à la variable vi peut être transformée en une solution affectant la valeur bj à vj et vice versa. Autrement dit, l’ensemble des solutions vérifiant l’affectation vi = bi est isomorphe à la solution dont vj = bj . On parle alors de solutions symétriques. Remarque 2.4.4 1. Si les variables vi et vj désignent la même variable, alors les deux définitions ci-dessus décrivent la symétrie des valeurs du même domaine. 2. Une symétrie sur toutes les solutions implique une symétrie par consistance. Manifestement, l’identification des symétries sémantiques est une tâche qui doit consommer beaucoup de temps, puisqu’elle requiert la résolution du problem. 6. Une variante symétrique est une nouvelle solution qu’on peut générer d’une soluiton du CSP

38

2.4.2

Symétrie syntaxique

La vérification de l’existence d’une symétrie sémantique nécessite la vérification des solutions une par une. Par conséquent l’étape de résolution est indispensable. Ce qui rend la symétrie sémantique lourde à démontrer. A travers les définitions 2.4.5 et 2.4.6 données dans (Benhamou, 1994), (Benhamou et Saïdi, 2007) et (Benhamou et Saïdi, 2007b), nous introduisons la symétrie syntaxique qui intègre la symétrie par rapport aux contraintes Définition 2.4.5 (Symétrie syntaxique inter-domaine) Une symétrie syntaxique interdomaines d’un CSP P = (V, D, C, R) est une application σ : V × ∪i∈[1,n] Di → V × ∪i∈[1,n] Di , qui associe à di ∈ Di , la valeur σ(di ) = dj ∈ Dj , où Di et Dj sont des domaines des variables CSP vi et vj , et qui garde le CSP P invariant. Définition 2.4.6 (Symétrie syntaxique variable-valeur) Deux paires variable-valeur hvi , bi i ∈ V × Di et hvj , cj i ∈ V × Dj sont syntaxiquement symétriques ssi il existe une symétrie syntaxique σ de P , telle que σ(hvi , bi i) = vj , cj . La relation entre la symétrie sémantique et la symétrie syntaxique a été introduite dans (Benhamou et Saïdi, 2007) à travers le théorème 2.4.7. Théorème 2.4.7 Si deux paires variable-valeur hvi , bi i ∈ V ×Di et hvj , cj i ∈ V ×Dj sont syntaxiquement symétriques, alors elles sont sémantiquement symétriques pour toutes les solutions du CSP .

2.5

Élimination des symétries

L’élimination des symétries est un principe qui permet d’accélérer le mécanisme de résolution. Une étape primordiale à réaliser avant l’élimination des symétries, est l’étape de détection des symétries du problème à traiter. On distingue deux types de symétries (Benhamou et Saïdi, 2007b) : – Les symétries globales : sont les symétries détectées sur le problème à l’origine. – Les symétries locales : sont les symétries détectées sur le problème à chaque nœud de résolution au niveau de l’arbre de recherche. En d’autres termes, les symétries globales sont les symétries détectées au niveau de la racine de l’arbre de recherche et qui peuvent ne pas être vérifiées au niveau des autres nœuds. 2.5.1

Élimination statique de symétries

Une élimination de symétrie statique est une approche basée sur l’addition de nouvelles contraintes au CSP initial, afin d’éliminer toutes les solutions symétriques. En d’autres termes, ces contraintes permettent de éliminer les symétries détectées et mènent vers un nouveau CSP sans symétries. Les symétries les plus traitées par l’approche statique, sont les symétries ligne et colonne (Flener et al., 2002, 2003; Kiziltan, 2004). Afin d’éliminer toutes les symétries ligne ou colonne, on peut ordonner les lignes (ou les colonnes) dans un ordre lexicographique. Les lignes (ou les colonnes) d’une matrice 2-d, sont ordonnées 39

dans un ordre lexicographique. Si une ligne (resp. une colonne) est, de point de vue lexicographique, plus petite que la suivante, et on note 6lex . Dans le cas d’ordre anti-lexicographique, chaque ligne (resp. une colonne) est plus grande que la ligne suivante, si elle est plus grande de point de vue lexicographique. L’exemple ci-dessous illustre un cas de matrice représentant des symétries ligne et colonne. Exemple 2.5.1 (Exemple sur les symétries ligne et colonne et l’ordre lexicographique)(Flener et al., 2002) X = {xi,j |i ∈ 1..3, j ∈ 1..4} DXi,j = {0, 1|i ∈ 1..3, j ∈ 1..4} {c1 , c2 } (2.2) P1 C =P c1 : ij xij = 7|∀i ∈ 1..3, ∀j ∈ 1..4 P c2 : ∀j 6= k, i xik xkj 6 1|∀i ∈ 1..3, ∀j ∈ 1..4 Ce modèle représente des symétries ligne et colonne. Une solution avec un ordre lexicographique, sur les lignes, peut être donnée comme suit :   0 1 0  0 1 1     1 0 1  1 1 0 Après avoir appliqué un ordre lexicographique sur les colonnes de la première solution on obtient la matrice :   0 0 1  0 1 1     1 1 0  1 0 1 Cependant, ceci détruit l’ordre lexicographique au niveau des colonnes. En réordonnant les deux dernières lignes, on obtient une matrice (ou une solution) avec un ordre lexicographique respecté autant sur les lignes que sur les colonnes :   0 0 1  0 1 1     1 0 1  1 1 0 Pour éliminer les symétries ligne et colonne, Flener et al. propose l’intégration de deux types de contraintes dans le CSP initial : l’une pour éliminer la symétrie ligne et l’autre pour éliminer la symétrie colonne. Par conséquent, durant la recherche, les contraintes d’ordre lexicographique fonctionnent en parallèle, à la fois au niveau des lignes et des colonnes. Le théorème ci-dessous 2.5.2 montre que, le fait que ce type d’ordre soit réalisé d’une manière séquentielle ou parallèle, on aura toujours une solution qui respecte l’ordre lexicographique lignes et colonnes. L’exploitation de ce type de contrainte est présenté dans la partie contribution, chapitre 4. Théorème 2.5.2 (Flener et al., 2002) Dans un modèle matriciel avec des symétries ligne et colonne dans une matrice 2 − d, chaque classe de symétries possède un élément dont les lignes et les colonnes de la matrice qui vérifient l’ordre lexicographique. 40

Malheureusement, l’application simultanée de l’ordre lexicographique sur les lignes et les colonnes peut laisser des symétries sur une matrice 2-d, un phénomène qu’on peut illustrer à travers l’exemple ci-dessous : Exemple 2.5.3 (Flener et al., 2001) Considérons la matrice 3 × 3 de variables xi,j 0-1, et qu’on peut définir à travers le CSP suivant : X = {xi,j |i, j ∈ 1..3} DXi,j = {0, 1|i, j ∈ 1..3} {c1 , c2 } (2.3) P2 C =P c1 : j=1..3 xi,j > 1, ∀j ∈ 1..3 P P c1 : i=1..3 j=1..3 xi,j = 4 Ce modèle représente les deux symétries : ligne et colonne. La résolution de P2 avec des contraintes imposant l’ordre lexicographique au niveau des lignes et des colonnes peut générer les solutions suivantes :       0 0 1 0 0 1 0 0 1  0 1 1  ,  0 1 0  , et  0 1 0  1 0 0 1 0 1 1 1 0 Par conséquent, on peut déduire que l’élimination des symétries ligne et colonne via l’application de l’ordre lexicographique sur les lignes et les colonnes, est une élimination de symétries partielle. 2.5.2

Élimination dynamique des symétries globales

Une élimination dynamique de symétries (Puget, 2006) contrairement à l’élimination statique, est basée sur deux points : 1. l’addition de nouvelles contraintes après chaque exploration d’un nouveau nœud de l’arbre de recherche. Ces contraintes, appelées contraintes conditionnelles, vont nous permettre d’éliminer les variantes symétriques de l’affectation (ou l’instanciaton) partielle en cours. 2. l’utilisation de chaque sous-arbre exploré sans succès comme un no-good pour éviter une exploration répétée de la variante symétrique. Parmi les méthodes les plus connues dans ce type d’élimination de symétries, on peut citer SBDS (Symmetry Breaking During Search)(Gent et Smith, 1999), LDSB (Lightweight Dynamic Symmetry Breaking) (Mears et al., 2014) et SBDD((Symmetry Breaking by Dominance Detection)(Gent et al., 2003). La méthode dynamique prise en considération dans notre travail est la méthode LDSB, raison pour laquelle nous exposons plus de détails sur cette méthode. LDSB est une méthode qui n’interagit pas avec l’heuristique de recherche utilisée. Elle peut être définie comme une descendante abrégée de la méthode SBDS (Gent et Smith, 1999). Elle ne demande à l’utilisateur que de fournir les différentes symétries, et elle fait un élagage des différentes parties symétriques de l’arbre de recherche dès que possible. Elle permet d’éliminer les symétries globales (détectées au au niveau de la racine de l’arbre) d’une manière dynamique. Le but de cette méthode est la possibilité de l’appliquer sur n’importe quel type de CSP et avec n’importe quelle stratégie de recherche. Ceci, en prenant comme 41

cible les groupes de symétries courantes en pratique, et qui peuvent être représentés d’une manière compacte et manipulés avec efficacité (voir l’exemple 2.5.4). Exemple 2.5.4 (le carré latin)(Mears et al., 2014) Le problème du carré latin de taille 3 comporte 3 × 3 cases, où chacune des 9 cellules du carré prend une valeur de l’ensemble {1, 2, 3}, de telle sorte que : chaque valeur apparaît une et une seule fois au niveau de chaque ligne et de chaque colonne. Le CSP correspondant peut être défini comme suit : X = {x1,1 , x1,2 , x1,3 , x2,1 , x2,2 , x2,3 , x3,1 , x3,2 , x3,3 } DXi,j = {1, 2, 3}, avec i, j ∈ 1..3 C = {x1,1 = x1,2 , x1,1 = x1,3 , x1,2 = x1,3 , x2,1 = x2,2 , x2,1 = x3,2 , x2,2 = x2,2 , x3,1 = x3,2 , x3,1 = x3,3 , (2.4) P3 x3,2 = x3,3 , x1,1 = x2,1 , x1,1 = x3,1 , x2,1 = x3,1 , x 1,2 = x2,2 , x1,2 = x3,2 , x2,2 = x3,2 , x1,3 = x2,2 , x = x ,x = x } 1,3

3,3

2,2

3,3

Le CSP P3 ci-dessus possède : 1. des symétries colonne : (x1,1 , x2,1 , x3,1 ) ↔ (x1,2 , x2,2 , x3,2 ), (x1,1 , x2,1 , x3,1 ) ↔ (x1,3 , x2,3 , x3,3 ), et (x1,2 , x2,2 , x3,2 ) ↔ (x1,3 , x2,3 , x3,3 ), 2. des symétries ligne, 3. des symétries par rapport à la diagonale, 4. une symétrie variable-valeur f définie par : f (xi,j = k) = (xj, k = i) Le CSP P3 admet toutes les symétries citées ci-dessus, puisque leurs applications 0 , appelée variante sur n’importe quelle solution Xsol mène vers une autre solution Xsol symétrique. Pour éliminer les symétries d’un CSP P = hX, D, Ci, la méthode LDSB génère et manipule les quatre groupes de symétries, que nous récapitulons comme suit (Mears et al., 2014) : Les variables interchangeables : L’ensemble des variables W ⊆ X sont interchangeables pour P si une extension fr de toute permutation de la variable r de W garde les variables dans X \ W inchangées alors r est une variable symétrique de P . Les valeurs interchangeables : L’ensemble des valeurs W ⊆ D sont interchangeables pour P si l’extension fl de toute valeur l de W garde les valeurs dans D ⊆ W inchangées, alors l est une valeur symétrique de P . Les variables interchangeables simultanément : Deux séquences de variables hx1 , ..., xn i et hy1 , ..., yn i , telles que hx1 , ..., xn i, hy1 , ..., yn i ∈ X sont simultanément interchangeables pour P , si hx1 , ..., xn i ↔ hy1 , ..., yn i, i.e. si la bijection qui associe chaque xi à yi et vice versa, garde le reste des variables de X inchangées, alors les deux séquences représentent des variables symétriques pour P . On dit que S est l’ensemble des séquences interchangeables pour P si :∀s1 , s2 ∈ S, s1 et s2 sont simultanément interchangeables. 42

Les valeurs interchangeables simultanément : Deux séquences de valeurs hx1 , ..., xn i et hy1 , ..., yn i, telles que hx1 , ..., xn i, hy1 , ..., yn i ∈ D sont simultanément interchangeables pour P , si hx1 , ..., xn i ↔ hy1 , ..., yn i. S est un ensemble de séquences de valeurs simultanément interchangeables pour P si ∀s1 , s2 ∈ S, s1 et s2 sont simultanément interchangeables. La méthode LDSB est une approche avancée, qui représente une version allégée de la la méthode SBDS. C’est une méthode considérée plus rapide et plus efficace, puisque l’exploitation des symétries ne se fait que sur celles qui sont actives après leurs compositions. Sachant, qu’une symétrie active est une symétrie qui garde l’instaciation partielle courante, au nœud n, inchangée (consistante). En d’autres termes, (Mears et al., 2014) la méthode LDSB possède : 1. un mécanisme qui permet de détecter les symétries qui sont toujours vérifiées parmi celles détectées au niveau racine. Ces symétries appartiennent aux quatre types de symétries à savoir : les variables interchangeables, les valeurs interchangeables, les variables interchangeables simultanément et les valeurs interchangeables simultanément, 2. des algorithmes très efficaces, pour traiter ces catégories de symétries. Enfin, LDSB est une méthode d’élimination de symétries dynamique et partielle qui donne des résultats performants en pratique.

2.6

Conclusion

Dans ce chapitre nous avons exposé les différentes approches que nous allons exploiter dans la résolution du modèle de conception de portefeuilles. Nous avons commencé par les approches incomplètes, où nous avons décrit trois types de méthodes, à savoir les méthodes locales simples, les méthodes à voisinage variable et une méthode à population. Pour les approches complètes nous avons introduit la programmation linéaire et la programmation par contraintes, en mettant en avant les techniques d’éliminations de symétries. L’exploitation des méthodes incomplètes sur le problème (P D) est exposée dans le chapitre 3. Le chapitre 4 étudie l’utilisation des méthodes complètes.

43

44

Deuxième partie

Contribution

45

Chapitre 3

Méthodes approchées pour le problème de conception de portefeuilles 3.1

Introduction

Ce chapitre est consacré aux approches locales de résolution du problème de conception de portefeuilles. Dans le chapitre 1, nous avons introduit l’état de l’art de ce problème, et mis en avant le modèle ensembliste introduit par Flener et al., notamment dans sa version (P D) via la formulation (1.2).puisque exemple Comme nous l’avons détaillé dans la section 1.5, (Flener et al., 2007) ont proposé une approche de résolution de (P D) basée sur des méthodes exactes. Une borne inférieure analytique de la valeur optimale de chevauchement associée au problème a été proposée, tout en précisant que cette borne sur les grandes instances est plutôt grossière (en comparaison avec la borne optimale). Pour pouvoir appréhender les grandes instances de (P D), ils ont proposé une stratégie pour décomposer le problème afin de ramener la résolution d’une grande instance donnée vers celle de petites instances du problème (P D). Finalement, d’un point de vue algorithmique, l’approche de Flener et al. (Flener et al., 2007) appliquée sur les grandes instances permet de trouver une solution pour une valeur donnée de chevauchement λ et une décomposition donnée (1.6). Mais dans le cas où l’approche ne parvienne pas à trouver une solution, on ne peut rien décider sur la consistance du problème, car il est probable qu’il existe une autre décomposition qui pourrait mener vers une solution. Dès lors que l’approche de Flener et al. n’explore pas toutes les décompositions, l’inconsistance du problème ne peut être certifiée. Finalement, l’approche de Flener et al. reflète le comportement des approches incomplètes. C’est la raison pour laquelle nous proposons dans ce chapitre à traiter le problème (P D) entièrement avec les algorithmes de recherche locale, et étudier dans quelle mesure ils pourraient concurrencer la démarche systématique de Flener et al. handicapée par le choix de la décomposition. Les méthodes de recherche locale ont prouvé leurs efficacité dans le traitement des problèmes combinatoires sur les grandes instances dans de nombreux domaines (e.g., voyageur de commerce, ordonnancement, etc.). Pour la résolution d’un problème combinatoire, quoique les méthodes exactes sont complètes et garantissent le 47

balayage de tout l’espace de recherche, elles s’avèrent pratiquement inefficaces sur les instances grandes et difficiles. En effet, dans le chapitre 4, les méthodes exactes (e.g., PLNE et PPC) se sont avérées coûteuses dans l’évaluation expérimentale des grandes instances du problème (P D). L’idée des méthodes locales consiste à explorer partiellement l’espace de recherche, mais intelligemment pour converger vers une solution de bonne qualité par rapport à la fonction objectif du problème (Pedroso, 2001). Nous proposons un algorithme glouton pour calculer une solution initiale, des fonctions de voisinages et une fonction coût qui tirent profit de la sémantique particulière des contraintes du modèle (P D). Ces fonctions seront utilisées pour faire appel à différentes recherches locales simples, à voisinages variables ou à population. Une implémentation a été réalisée sous l’environnement INCOP (Neveu et Trombettoni, 2003), permettant d’entreprendre une évaluation expérimentale détaillée de ces différentes approches locales. Nous avons implémenté sous INCOP de nouvelles classes et de nouvelles méthodes, afin d’y intégrer le traitement des CSPs n-aires, des méthodes à voisinage variable et des différentes fonctions de voisinage et des fonctions d’évaluation.

3.2

Modèle matriciel

Le modèle de conception d’un portefeuille financier (P D) (Portfolio Design)(Flener et al., 2007) décrit les relations entre les différentes tranches d’un CDO2 (Whetten et Adelson, 2005; Guillaume et al., 2008). Dans le cas où le CDO2 est constitué de v tranches, dont chaque tranche contient r actifs. Chaque paire de tranches partage au plus λ actifs. La taille de l’univers des actifs est 250 ≤ b ≤ 500. Un portefeuille typique est contraint par 4 ≤ v ≤ 25 tranches, dont chacune est de dimension r ≈ 100. Flener et al. (Flener et al., 2007) ont proposé un modèle ensembliste que nous reformulons sous forme d’un modèle matriciel en 0-1, décrit dans la définition suivante. Définition 3.2.1 (Modélisation d’un portefeuille - (P D)) Le portefeuille P Dhv, b, r, λi comporte v tranches et b portefeuilles d’actifs. Le problème (P D) consiste en v tranches d’actifs V1 , ..., Vv , dont chaque tranche a r actifs choisis parmi b portefeuilles (contrainte ligne). En plus d’une condition d’équilibre, chaque paire de tranches contient au maximum λ éléments en commun (contrainte de chevauchement ou contrainte colonne). Soit M1..v,1..b une matrice booléenne, dont Mi,j = 1 si et seulement si l’actif j est choisi dans la tranche i, et 0 sinon. Ce qui mène vers le modèle matriciel suivant : P  Mi,j = r  ∀i ∈ 1..v, j∈1..b P (P D hv, b, r, λi) ∀i ∈ 1..v, ∀t > i, bj=1 Mi,j Mt,j ≤ λ (3.1)  ∀i ∈ 1..v, ∀j ∈ 1..b, Mi,j ∈ {0, 1} Le problème d’optimisation (OP D) consiste à minimiser le nombre de chevauchements λ sous les contraintes constituant (P D) :  minλ (OP D hv, b, r, λi) (3.2) (P D) 48

Une configuration du problème (P D) est représentée par la matrice M1..v,1..b , où ∀i ∈ 1..v, j ∈ 1..b, Mi,j ∈ {0, 1}. Résoudre (P D) consiste à trouver une configuration, dont chaque ligne comporte r unités, et le chevauchement entre n’importe quelles deux lignes est inférieur ou égal à λ (voir l’exemple 3.2.2). Exemple 3.2.2 Comme le montre la Figure 3.1, la résolution de l’instance P D h10, 8, 3, 2i consiste à trouver une matrice M dont chaque ligne contient exactement r = 3 unités et tous les chevauchements sont inférieurs ou égaux à λ = 2.

Figure 3.1 – Exemple de la structure matriciel du modèle (P D)

(P D) est un problème de satisfaction de contraintes, alors que (OP D) est un problème d’optimisation. Le problème (OP D) (Flener et al., 2007) est plus difficile, car les chevauchements au niveau de chaque paire de lignes (tranches) sont minimisés. Ceci mène vers une construction forte des tranches de CDO2 . Le problème (P D) est également difficile à résoudre car il contient des contraints quadratiques sur des variables booléennes.

3.3

Exemple de motivation

Pour illustrer l’intérêt de notre approche, considérons l’instance P Dh10, 37, 14, 6i. Comme illustré dans la Table 3.2, alors que l’approche de Flener et al. (Flener et al., 2007) résout P Dh10, 37, 14, 6i avec λ = 6, notre approche basée sur une recherche locale à voisinage variable (VNS) produit une solution de meilleure qualité λ = 5.06. Notre approche adopte la méthode VNS biaisée (skewed VNS) utilisant la méthode locale simple IDW (Neveu et al., 2004) et la fonction de voisinage Swap (détaillée dans la section 3.4.2.2). Suivant la Table 3.2, notre approche basée sur VNS est 49

plus efficace que l’approche systématique proposée par Flener et al., relativement au nombre moyen de chevauchements et au temps d’exécution 1 . Dans (Flener et al., 2007), pour résoudre le modèle mathématique (P D) les contraintes d’inégalité sont remplacées par des contraintes d’égalité. Dans notre approche, nous appréhendons directement le problème original (P D) en essayant de casser la difficulté de satisfaire les contraintes d’inégalité. Dans la Table 3.1, nous présentons la solution donnée par la méthode VNS (décrite dans la section 3.7). Table 3.1 – La solution de P Dh10, 37, 14, 6i avec l’approche VNS 0100100100011100000000011010111001001 0110101001100000011000100000011011001 0000000100000000101110100001110011111 0 0 0 1 0 1 0 1 1 1 1 0 0 0 0 0 0 1 0 1 0 1 1 0 1 0 0 0 0 0 0 1 0 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 1 0 0 0 1 0 1 1 0 1 0 1 0 1 0 0 0 1 0 0111010011001000011010001000010000110 1000001001010010000110001110001100011 0000010110110010010010100110110000100 0101001010101001000000110110001100010 1101111001011000000101100000000010010

Table 3.2 – Le nombre moyen de chevauchements et les temps d’exécution de l’approche de Flener et al. et l’approche VNS sur l’instance P Dh10, 37, 14, 6i

average overlap temps CPU (secondes)

Flener et al. 6.00 1.28

SVNS-IDW-Swap 5.06 0.06

Dans la solution trouvée par (Flener et al., 2007), toutes les paires ont exactement 6 chevauchements, alors que notre solution a nettement moins de chevauchements. Dans la Table 3.1, nous avons deux cas particuliers intéressants : – la paire en italique-gras contient 3 chevauchements, – la paire en gras contient 6 chevauchements. Dans la solution donnée dans la Table 3.1, le nombre de chevauchements de toutes les paires de lignes est compris dans l’intervalle [3, 6]. Le nombre moyen de chevauchements donné dans la Table 3.2 montre bien que notre solution est meilleure que celle de Flener et al., i.e. avec notre solution nous fournissons une meilleure diversification des portefeuilles, et donc un meilleur équilibre risque/rentabilité. 1. Les expérimentations de (Flener et al., 2007) ont été réalisées sur une machine avec un processeur AMD Athlon XP 2400+ qui est plus lent que notre machine (Intel CPU E5-2603) avec un facteur 8 Voir le benchmarking des processeurs disponible sur le site http ://www.cpubenchmark.net/singleThread.html. L’indice de performances du processeur AMD Athlon XP +2400 est 462, et celui du processeur Intel CPU E5-2603 est 3765. En somme, notre temps doit être multiplié par 8.

50

3.4

Composants de base des recherches locales

Comme toute recherche locale, nos approches démarrent avec une configuration complète mais non optimale (ou des configurations dans le cas des méthodes à population). Ici, on se met dans un cadre de minimisation. La méthode locale répare la solution courante en appliquant des changements locaux qui vont décroître une fonction coût. Les composants de base de nos méthodes locales (Walser, 1999) sont : Problème combinatoire : Nous considérons le problème (P D). Fonction coût : Le problème est de trouver une solution optimale qui minimise globalement une fonction coût. La section 3.4.1 détaille la fonction coût. Fonction de voisinage : Soit une configuration donnée M . La fonction de voisinage définit l’ensemble des configurations voisines N (M ) de M que nous pouvons obtenir en appliquant de petits changements sur M . Une configuration est localement optimale relativement à la fonction de voisinage si son coût est meilleur que celui de tous ses voisins. Nous avons utilisé deux fonctions de voisinage détaillées dans la section 3.4.2. Stratégie de contrôle : Elle définit comment les configurations sont explorées. Les sections suivantes détaillent nos stratégies, soit par recherche locale simple (section 3.6), soit par voisinage variable (section 3.7), soit à population (section 3.8). 3.4.1

Fonction coût

Conceptuellement, une instance du problème (P D) est caractérisée par son espace faisable et sa fonction objectif qui associe à chaque solution une valeur coût. La fonction coût Eval consiste à comptabiliser le nombre de contraintes non-satisfaites dans (P D) relativement à une configuration M : X  +1 si la ime contrainte est non-satisfaite avec M Eval(M ) = (3.3) 0 sinon k∈1..m

où m est le nombre de contraintes. La fonction Eval est aussi la fonction objectif du problème d’optimisation que l’on se pose pour résoudre le problème (P D). Bien évidemment, les solutions optimales correspondent aux configurations qui résolvent toutes les contraintes du problème (P D). 3.4.2 3.4.2.1

Fonctions de voisinage Fonction de voisinage flip

La première fonction de voisinage pour le problème (P D) est la fonction Flip où une affectation 0-1 M 0 est dite voisine d’une autre affectation 0-1 M si M 0 peut être obtenue à partir de M en inversant (changeant) la valeur d’une variable donnée. Le choix de la variable dépend de la méthode de recherche locale : Recherche à voisinage variable : Dans le cas de VNS, la variable sélectionnée Ml,c est choisie aléatoirement (pour plus de détails voir les algorithmes de la section 3.7). 51

Recherches locales simples : Dans le cas des recherches locales simples (e.g., recuit simulé, IDWalk et recherche taboue, considérées dans notre travail), nous repérons les deux indices (l, c) de la variable sélectionnée Ml,c ayant le plus de conflits et la moins changée : (l, c) = argmaxi∈1..v,j∈1..b (abs(val_conf licti,j ) − compti,j ) où compti,j est le compteur qui stocke le nombre de fois où la variable Mi,j a été changée. La matrice val_conf lict contient l’évaluation des conflits des variables individuelles Mi,j de la variable matricielle M . Nous associons une valeur de conflit val_conf licti,j à chaque variable Mi,j , définie comme suit :  +1 si Mi,j ∈ vars(Ck ), Ck est sous la forme     "fk (M ) = 0" et val(fk (M )) < 0    X  −1 si Mi,j ∈ vars(Ck ), Ck est sous la forme "fk (M ) = 0" et val(fk (M )) > 0 val_conf licti,j =   k∈1..m  −1 si Mi,j ∈ vars(Ck ), ,Ck est sous la forme    "fk (M ) ≤ 0" et val(fk (M )) > 0   0 sinon. (3.4) où m est le nombre de contraintes, vars(Ck ) est l’ensemble des variables qui apparaissent dans Ck , val(fk (M )) évalue la fonction fk au niveau de M . L’idée de cette fonction d’évaluation consiste à calculer val_conf licti,j en ajoutant +1 (resp. −1), si le membre gauche de la contrainte Ck doit être diminuée (resp. augmentée) pour la satisfaire. Soit M [1..v] [1..b] une configuration donnée, nous dénotons V arConf lict la variable ayant le plus grand conflit. 3.4.2.2

Fonction de voisinage swap

Supposons que la recherche locale commence par une affectation où r unités sont placées dans chaque ligne, faisant ainsi la contrainte X ∀i ∈ 1..v, Mij = r j∈1..b

pleinement satisfaite. Pour garder cette contrainte ligne constamment satisfaite, nous adoptons la fonction de voisinage swap qui consiste à inter-changer entre deux variables, une ayant la valeur 0, et l’autre la valeur 1. Plus précisément, la fonction swap dans toutes les recherches locales étudiées, procèdent en trois étapes : 1. Sélection aléatoirement une variable Ml,c1 parmi celles ayant la valeur 1. 2. Sur la même ligne que la variable précédemment sélectionnée, choisir aléatoirement une seconde variable Ml,c2 parmi celles fixées à 0. 3. Affecter 0 à Ml,c1 , et 1 à Ml,c2 . Dès lors que la contrainte ligne est tout le temps satisfaite, les méthodes de recherche locale adoptant cette fonction de voisinage doivent résoudre seulement les contraintes de chevauchement : ∀i ∈ 1..v, ∀t > i,

b X j=1

52

Mij Mtj ≤ λ.

3.5

Algorithme glouton pour calculer la solution initiale

Les algorithmes de recherche locale nécessitent une configuration initiale pour démarrer la recherche. Une configuration initiale générée aléatoirement est souvent utilisée dans les méthodes de recherche locale. Le but de l’algorithme glouton 8 (Lebbah et Lebbah, 2015a), est de fournir une configuration M avec très peu de contraintes violées, en comparaison avec une solution générée aléatoirement. GreedyInit prend en compte l’origine de la contrainte en question : Ct = ”Row” pour exprimer la contrainte ligne, et Ct = ”Overlap” pour la contrainte de chevauchement. La première boucle de GreedyInit essaie de remplir des diagonales afin de satisfaire, aussi bien que possible, la contrainte de chevauchement. La deuxième boucle a pour but de satisfaire le maximum de contraintes lignes. L’algorithme tente de remplir r cellules au niveau de chaque ligne. Lors de la première itération, l’algorithme fait un saut de λ colonnes, et λ + 1 sauts dans le reste des itérations. L’accroissement du nombre de sauts est grand, induit la diminution du risque de violation des contraintes de chevauchement. Nous fixons le nombre de sauts à λ + 1 pour ne pas trop pénaliser la contrainte ligne. Algorithm 8 GreedyInit(P D < v, b, r, λ >) Input: v nombre de tranches ; b nombre de titres ; r nombre de titres par tranche ; λ nombre de chevauchement maximal ;M matrice v × b initialisée à zéro ; Output: Une configuration matricielle M [v × b] réduisant le nombre de conflits {Overlap constraint} 1: for i ∈ 1..λ + 1 do 2: FillDiagonal(i, "Overlap") 3: end for{Row constraint} 4: i ← λ + (λ + 1) 5: while i ≤ b do 6: FillDiagonal(i , "Row") 7: i ← i + (λ + 1) 8: end whilereturn M

L’algorithme GreedyInit est basé sur l’algorithme FillDiagonal 9, qui remplit avec des 1 la diagonale démarrant de la cellule (1, i). FillDiagonal commence par calculer le nombre maximal de cellules (variable M ax dans l’algorithme) qui permet de remplir la diagonale en commençant par la cellule (1, i). M ax dépend des dimensions de la matrice et la valeur i. Par exemple, soit la matrice (3.5), la diagonale dont la première extrémité (1, i = 1) présente M ax = 7 cellules à remplir ; la diagonale dont l’extrémité (1, i = 2) possède M ax = 6 ; et la diagonale avec (1, i = 4) représente M ax = 4. La première boucle de l’algorithme FillDiagonal remplit la diagonale de l’extrémité (1, i) jusqu’à la dernière ligne ou colonne, selon la valeur de la variable M ax. Afin de satisfaire les contraintes ligne et colonne, dans la deuxième boucle, FillDiagonal complète la première boucle en remplissant la deuxième diagonale, avec la ligne suivante comme point de démarrage, en d’autres termes la cellule (M ax + 1, Jump + 1). La variable Jump dépend de la nature de la contrainte en question. Concernant la contrainte ligne, puisque nous considérons uniquement la ligne en cours, la valeur Jump = 0 exprime le début de la diagonale égal à (M ax + 1, 1). Mais, pour la contrainte de chevauchement, nous devons éviter 53

Algorithm 9 F illDiagonal(i, Ct) Input: v nombre de tranches ; b nombre de titres ; M matrice v × b ; Ct = "Overlap" ou "Row" Output: Remplir la diagonale de M [v × b] en commençant par (1, i) M ax ← si (b ≥ (min(v, b) + i − 1)) alors min(v, b) sinon b − i + 1 2: for j ∈ 1..M ax do M [j] [i + j − 1] ← 1 4: end for if Ct = ”Overlap” then 6: Jump ← (i − (b − min(v, b) + 1)) else 8: if Ct = ”Row” then Jump ← 0 10: end if end if 12: for j ∈ 1..v − M ax do M [M ax + j] [Jump + j] ← 1 14: end forreturn M

l’accroissement du taux de chevauchements avec les autres lignes. Par conséquent, la variable Jump est fixée à i − (b − min(v, b) + 1) pour éviter des chevauchements avec les i premières diagonales. Dans ce cas, nous intégrons dans notre algorithme l’estimation d’un certain écart b − min(v, b) pour v ≥ b. L’algorithme GreedyInit est illustré dans (3.5). La première diagonale commence de (1, 1) et se termine à (7, 7). La troisième diagonale comporte les deux extrémités (1, 4) et (4, 7), mais dans le cas où la diagonale n’atteint pas la dernière ligne, l’algorithme doit continuer avec une diagonale commençant par la ligne suivante (5, 1) jusqu’à atteindre la dernière ligne (7, 3). Nous remarquons que l’application de notre algorithme sur l’instance P D < 7, 7, 3, 1 > nous permet d’obtenir directement une configuration avec 0 contraintes violées (voir la table ci-dessous).

MP D

11 12 0 13 0 0 0 0 11 12 0 13 0 0 0 0 11 12 0 13 0 = 0 0 0 11 12 0 13 13 0 0 0 11 12 0 0 13 0 0 0 11 12 12 0 13 0 0 0 11

(3.5)

Soit la deuxième instance P D < 10, 8, 3, 2 > qui comporte plus de lignes que de colonnes. 54

MP D

11 0 0 0 0 = 0 0 0 11 0

12 11 0 0 0 0 0 12 0 11

13 12 11 0 0 0 13 0 12 0

0 13 12 11 0 0 0 13 0 12

0 0 13 12 11 0 0 0 13 0

0 0 0 0 0 0 0 0 0 13 0 0 12 13 0 11 12 13 0 11 12 0 0 11 0 0 0 13 0 0

Après l’application de l’algorithme 8, nous obtenons la configuration MP D avec 0 conflits. Maintenant, soit l’instance P D < 8, 14, 7, 3 > ayant plus de colonnes et de lignes.

MP D

11 12 0 11 16 0 0 16 = 0 0 0 0 0 0 15 0

13 12 11 0 16 0 0 0

14 13 12 11 0 16 0 0

0 14 13 12 11 0 16 0

0 0 14 13 12 11 0 16

0 0 0 14 13 12 11 0

15 0 0 0 14 13 12 11

0 0 0 0 16 0 15 0 0 0 0 16 0 15 0 0 0 0 0 0 15 0 0 0 0 0 0 15 0 0 14 0 0 0 15 0 13 14 0 0 0 15 12 13 14 0 0 0

Après l’application de l’algorithme 8, nous obtenons une configuration avec 8 conflits. Proposition 3.5.1 L’algorithme 8 a une complexité au pire des cas, de l’ordre de O(vr). Preuve Au plus r cellules par ligne sont remplies, ce qui ne peut pas dépasser vr opérations à exécuter. 2 La proposition suivante introduit des propriétés intéressantes, indiquant les cas où l’algorithme glouton réussit à satisfaire toutes les contraintes du modèle Proposition 3.5.2 Si – λ + 1 = r ou – (λ + 1 < r) ∧ 2(λ + 1) + (r − (λ + 1) − 1)(λ + 2) ≤ b alors toutes les contraintes lignes sont vérifiées. Si une des conditions ci-dessus est satisfaite, et (r ≤ λ + 3), alors toutes les contraintes de chevauchement sont vérifiées. Preuve Dans la première boucle de l’algorithme 8, nous réussissons à affecter λ+1 cellules avec la valeur 1 au niveau de chaque ligne, afin de satisfaire les contraintes lignes. La deuxième boucle de l’algorithme affecte la valeur 1 aux r − (λ + 1) cellules restant au niveau de chaque ligne. A chaque itération et dans chaque ligne, le nombre de 1 affectés diminue. Dans la deuxième boucle, si λ + 1 6= r alors nous devons avoir 2(λ + 1) + (r − (λ + 1) − 1)(λ + 2) ≤ b afin de satisfaire toutes les contraintes lignes. 55

Plus précisément, puisque dans la deuxième boucle, i est incrémenté de (λ + 2), les (r − (λ + 1) − 1) cellules vides qui restent, doivent être affectées de 1 sans dépasser b. Ce qui introduit la première propriété de la proposition. Après la première boucle de l’algorithme 8, nous obtenons au plus λ chevauchements. Après la première boucle, FillDiagonal est appliqué sur la diagonale 2(λ + 1). De cette manière, nous assurons la satisfaction des contraintes de chevauchement. Dans la deuxième boucle nous traitons les diagonales démarrant des positions espacées de λ+2 lignes. Lors du remplissage de la première diagonale, cette dernière est espacée de λ + 2. Les contraintes de chevauchement demeurent toujours vérifiées. Mais, dans le reste des diagonales, le risque de violer des contraintes de chevauchement se manifeste. Par conséquent, quand r ≤ λ + 1 + 1 + 1 les contraintes de chevauchement sont certainement vérifiées. 2 En utilisant l’algorithme glouton pour calculer la solution initiale, il faut s’attendre à un comportement différent d’une solution générée aléatoirement. Systématiquement, avec une solution initiale aléatoire, l’algorithme peut générer plus de solutions qu’avec une solution générée par un algorithme glouton. Cependant, en dépit du taux de variation des solutions générées à travers une solution initiale aléatoire, la qualité des solutions générées à travers une solution initiale calculée, demeurent meilleure. Dans nos expérimentations (voir la section 3.9.3.2), la version gloutonne est plus performante que la version aléatoire. Mais, en pratique, à cause de l’esprit de l’algorithme glouton 8, il existe sûrement des solutions initiales S 00 plus intéressantes mais ignorées par notre stratégie gloutonne. Conformément au théorème d’optimisation no-free-lunch (Wolpert et Macready, 1997), la version aléatoire d’une solution doit être plus efficace sur des instances de S 00 . D’après ce théorème et d’un point de vue théorique, nous pouvons avoir ce comportement. Mais, encore une fois, les expérimentations réalisées sur les instances citées dans (Flener et al., 2007) sont mieux résolues via la version gloutonne.

3.6

Méthodes de recherche locale simple

Nous avons exploité trois algorithmes de recherche locale : IDWalk method Nous avons adopté le schéma algorithmique décri dans la section 2.2.1.2. La description de son paramétrage est détaillé dans la section expérimentale de ce chapitre. La méthode taboue L’algorithme taboue n’a pas été modifié par rapport à celui donné dans la section 2.2.1.3. Son paramétrage est aussi décrit dans la section expérimentale. Recuit simulé L’algorithme décrit dans la section préliminaire 2.2.1.1 a été légèrement revu et décrit comme suit. Les étapes principales du recuit simulé appliqué sur le problème (P D) décrit par le modèle (3.1), sont comme suit : 1. Démarrer avec une solution initiale S0 , et l’évaluer par Eval(S0 ) où Eval est la fonction objectif. 2. Si la fonction de voisinage choisie est flip, choisir la variable V arconf ict la moins choisie et ayant la plus grande valeur absolue de val_conf lict (calculé avec la formule (3.4)). Sinon, si la fonction de voisinage est swap, 56

choisir aléatoirement deux variables appartenant à la même ligne, et ayant les valeurs respectives 0 et 1, puis permuter leurs valeurs. 3. Suivant la fonction de voisinage choisie, changer la valeur de la variable V arconf ict , puis calculer une nouvelle solution S1 dans le voisinage de S0 . Évaluer S1 avec Eval(S1 ) (comme indiqué dans la section 3.4). (a) si (Eval(S0 ) ≥ Eval(S1 )) alors S1 est adoptée tout en améliorant la solution S0 . (val(S1 ) − val(S0 ) T . (b) si (Eval(S0 ) < Eval(S1 )) alors on calcule ν = exp Choisir aléatoirement une valeur r dans l’intervalle [0, 1]. Si (r ≤ ν) alors remplacer S0 par S1 et mettre à jour la matrice val_conf lict. 4. Décrémenter T doucement à chaque itération. Si (T ≤ 0) alors arrêter et déclarer la solution S0 comme étant une solution optimale sinon aller à l’étape 2. La recherche locale appliquée à ce niveau est différente d’une recherche locale standard, puisque dans le cas de la fonction de voisinage flip, la fonction de transition n’est pas conforme au choix aléatoire du voisin. Tandis que, dans notre algorithme, dans le cas flip, on choisit le meilleure voisin, ce qui nous fait perdre les propriétés des chaînes de Markov (Henderson et al., 2003)qui garantissent la convergence. En ce qui concerne la terminaison de l’algorithme, elle est garantie par la décroissance stricte de la température. Bien évidemment, il faudra que cette décroissance de la température converge en un temps fini vers zéro ; ceci est garantie sur machine, vue la finitude des nombres flottants.

3.7

Méthodes de recherche locale à voisinage variable (VNS)

La recherche locale à voisinage variable (Variable Neighborhood Search (VNS)) (Mladenovic et Hansen, 1997) est une métaheuristique qui exploite une technique de recherche locale donnée pour échapper au phénomène des minima locaux. L’idée de la stratégie VNS est d’explorer partiellement l’espace de recherche avec des changements systématiques de la structure de voisinage. Le succès de VNS vient du fait qu’un minimum local dans une structure de voisinage ne l’est pas nécessairement dans une autre structure, permettant ainsi d’éviter autant que possible de se faire piéger par des minima locaux. Le pseudo-code de l’algorithme VNS est donné dans l’Algorithme 10. Il démarre avec une sélection d’une matrice de configuration initiale. Les fonctions RL et Shake sont au coeur de l’exploration de l’espace de recherche. La fonction Shake diversifie la solution en changeant k variables choisies aléatoirement. De ce fait, accroître k permet à l’algorithme VNS de visiter des configurations distantes de la configuration courante. Le résultat M 0 de la fonction Shake est utilisé comme un point de démarrage de la recherche locale RL. Suite à l’appel de RL, la solution calculée M 00 est comparée avec M en utilisant la fonction coût Eval. Nous rappelons que la fonction coût Eval consiste à comptabiliser le nombre de contraintes non-satisfaites dans (P D) relativement à une configuration donnée M (voir (3.3)). Si M 00 est meilleur que M , la configuration M 00 est affectée à M et l’algorithme réitère le traitement avec k = 1. Sinon, k est incrémenté et l’algorithme continue en appliquant la phase 57

Algorithm 10 VNSPD(RL, Kmax , SM) Input: P Dhv, b, r, λi ; Kmax paramètre de VNS ; RL méthode de recherche locale ; SM méthode pour générer un nouveau point dans le voisinage 1: Initialiser M aléatoirement 2: while (non time-out) et (Eval(M ) 6= 0) do 3: k ← 1; 4: while (k ≤ Kmax ) et (Eval(M ) 6= 0) et (non time-out) do 5: M 0 ← Shake(SM, M, k) ; 6: M 00 ← LS(M 0 ) ; 7: if Eval(M 00 ) < Eval(M ) then 8: M ← M 00 ; 9: k ← 1; 10: else 11: k ← k + 1; 12: end if 13: end while 14: end while 15: procedure Shake(SM, M, k) 16: M0 ← M ; 17: for i in 1..k do 18: if SM = Flip then % Parcours du voisinage avec la fonction Flip 19: (i, j) ← RandomSelectIn(1..v, 1..b) ; 0 ← abs(1 − M 0 ) ; 20: Mi,j i,j 21: else % Parcours du voisinage avc la fonction Swap 22: l ← RandomSelectIn(1..v) ; 23: v1 ← RandomSelectIn(1..b) avec Ml,v1 = 1 ; 24: v0 ← RandomSelectIn(1..b) avec Ml,v0 = 0 ; 0 0 25: Ml,v ← 0 ; Ml,v ← 1; 1 0 26: end if 27: end for 28: Return M 0 ; 29: end procedure

Shake avec la nouvelle structure de voisinage. La boucle interne prend fin une fois que toutes les structures de voisinage sont explorées ou une solution satisfaisant toutes les contraintes est trouvée. La boucle externe itère jusqu’à ce que le temps CPU soit épuisé ou qu’une solution est atteinte. 3.7.1

Recherche locale à voisinage variable biaisée (skewed VNS)

En général, VNS trouve de meilleurs résultats comparativement aux méthodes de recherche locale simple, tout particulièrement quand le paysage des solutions contient de nombreux minima locaux. Ceci peut s’expliquer par le fait que VNS a une grande facilité pour explorer des voisins lointains pour éviter le phénomène des minima locaux. En conséquence, adopter souvent des voisins lointains force la méthode VNS à se comporter pratiquement comme une méthode multistart 2 , et 2. Une méthode multistart est entièrement basée sur les techniques de recherche d’optima locaux. Le principe consiste à effectuer de nombreuses recherches locales dans des parties du domaine déterminées

58

empêche VNS de converger par petits changements locaux au minimum global. Justement pour y remédier, une nouvelle variante de VNS, SVNS (pour Skewed Variable Neighborhood Search), a été proposée. Cette version révisée de VNS, SVNS, est donnée dans l’algorithme 11 SVNSPD. Dans cette variante, nous relâchons la condition d’adoption d’une nouvelle solution. Plus précisément, au lieu d’utiliser la fonction coût Eval, on utilisera une autre qui se permet un certain degré de tolérance dans le solution courante, dans l’objectif d’intensifier la recherche toujours autour de la solution courante et dans la structure courante de voisinage, et retarder le changement de la structure de voisinage. La relaxation de la condition d’adoption de la solution avec la fonction Eval, utilise une fonction d’évaluation linéaire de la distance : l’expression Eval(M 00 ) est remplacée par Eval(M 00 ) − αρ(M, M 00 ) où ρ(M, M 00 ) est une distance entre M et M 00 , et α est un paramètre donné. Dès lors qu’on a des variables booléennes, nous avons adopté la distance de Hamming 3 . Le paramètre α est fixée à la valeur par défaut 1 (Fonseca et Santos, 2014). Algorithm 11 SVNSPD(RL, Kmax , SM) Input: P Dhv, b, r, λi ; Kmax paramètre de VNS ; RL méthode de recherche locale ; SM méthode de génération du nouveau point 1: Initialiser M aléatoirement 2: while (non time-out) et (Eval(M ) 6= 0) do 3: k ← 1; 4: while (k ≤ Kmax ) et (Eval(M ) 6= 0) et (non time-out) do 5: M 0 ← Shake(SM, M, k) % se référer à la fonction Shake dans l’algorithme 10 6: M 00 ← LS(M 0 ) ; 7: if Eval(M 00 ) < Eval(M ) then 8: M ← M 00 ; k ← 1 ; 9: else 10: α←1 00 6= M } 11: ρ = card{(i, j)|i ∈ 1..v, j ∈ 1..b, Mi,j i,j 12: if Eval(M 00 ) − αρ < Eval(M ) then 13: M ← M 00 ; 14: k ← 1; 15: else 16: k ← k + 1; 17: end if 18: end if 19: end while 20: end while

3.8

Méthode de recherche locale à population GWW

La dernière approche locale appliquée sur le problème (P D) est la méthode à population GWW (Go With the Winners)(Lebbah et Lebbah, 2012) décrite dans aléatoirement. 3. La distance de Hamming entre deux vecteurs a et b dans {0, 1}n , notée par d(a, b) est définie comme L Pn−1 suit : d(a, b) = i=0 ai bi

59

la section 2.2.3. Dans (Neveu et Trombettoni, 2003), la marche aléatoire a été remplacée par une méthode locale (e.g., la méthode taboue, le recuit simulé, ...). Pour appréhender le problème (P D), nous adoptons l’algorithme 6, en utilisant au lieu de la marche aléatoire, une recherche locale simple (Neveu et al., 2004). Le paramétrage de la méthode est détaillé dans la section expérimentale de ce chapitre.

3.9

Etude expérimentale

Nos expérimentations sont réalisées sur le problème (P D) où λ est fixé à la borne inférieure du chevauchement proposée par Flener et al. L’implémentation a été réalisée sous INCOP avec l’intégration des fonctions de voisinage et la fonction d’évaluation (décrites dans la section 3.4). La machine utilisée possède les caractéristiques suivantes : Linux-ubuntu 12.04, Intel CPU E5-2603 et 8 GB/RAM. Nous avons fixé le temps limite à 200 secondes. 3.9.1

Mise en œuvre des algorithmes sous INCOP

INCOP(An Open Library for INcomplete Combinatorial OPtimization) (Neveu et Trombettoni, 2003) est un solveur de résolution approchée écrit en C++. Il regroupe un nombre important de méthodes locales et une méthode à population GWW (Go With the Winners) (Dimitriou et Impagliazzo, 1996; Neveu et Trombettoni, 2004). INCOP est conçu pour la résolution des CSPs avec des contraintes linéaires et les MAX-CSP. La gestion des voisinages ainsi que les mouvements est conçue dans le but de faciliter son exploitation par le programmeur et l’utilisateur de l’outil. C’est une bibliothèque extensible qui autorise des extensions vers de nouvelles méthodes locales. L’outil INCOP a montré d’excellentes performances sur des problèmes de référence. On peut citer le problème de coloration de graphes flat300_28 qui a été colorié pour la première fois en 30 couleurs, en appliquant la méthode Metropolis. Le modèle (3.1) utilisé dans la résolution, est un modèle contenant deux types de contraintes : – les contraintes lignes, qui sont linéaires, – les contraintes de chevauchements, qui sont quadratiques Pour exploiter la bibliothèque INCOP, nous étions obligés de l’étendre pour qu’il soit applicable sur les modèles contenant des contraintes n-aires. Concernant les méthodes locales appliquées sur le modèle, nous avons exploité les algorithmes suivants : – le recuit simulé, – la méthode taboue, – la méthode à population GWW. Nous avons fait appel à l’algorithme VNS (Variable Neighboorhood Search) et l’algorithme Swap-VNS (VNS biaisé), que nous avons mis en œuvre sous INCOP. 3.9.2

Protocole expérimental

La Table 3.3 décrit les paramètres des instances (P D) expérimentées ainsi que leur nombre de contraintes et de variables. 60

Table 3.3 – Les instances expérimentées Instance Inst1 Inst2 Inst3 Inst4 Inst5 Inst6 Inst7 Inst8 Inst9 Inst10 Inst11 Inst12 Inst13 Inst14 Inst15 Inst16

hv, b, r, λi h7,7,3,1i h10,8,3,2i h8,14,7,3i h11,11,5,2i h16,8,3,1i h10,15,6,2i h9,18,8,3i h9,24,8,2i h15,15,4,1i h10,25,8,2i h10,30,9,2i h9,37,12,3i h10,37,14,6i h10,38,10,2i h19,20,9,4i h15,350,100,25i

Nombre de variables 49 80 112 121 128 150 162 216 225 250 300 333 370 380 380 5250

Nombre de contraintes 28 55 36 66 136 55 45 45 120 55 55 45 55 55 190 1575

Nous commençons notre étude expérimentale par évaluer les performances de l’algorithme glouton au niveau de la section 3.9.3.1. Par la suite, nous avons étudié les méthodes de recherche locale suivantes : Recherches locales simples : Nous avons expérimenté les méthodes du récuitsimulé, IDWalk et taboue. En premier, nous commençons par la résolution du problème avec une configuration initiale 4 aléatoire. En deuxième position nous essayons de résoudre le problème tout en démarrant d’une configuration initiale calculée par l’algorithme glouton 8. Les paramètres des méthodes locales expérimentées sont fixés comme suit : le nombre max de mouvements est 10 000 ; le nombre max de voisins est 300. L’évaluation de ces paramètres est le résultat d’une suite de tests et les recommandations générales données dans (Neveu et Trombettoni, 2003; Neveu et al., 2004). L’unique paramètre du recuit simulé, est la température initiale fixée à 0.4. Pour la méthode IDWalk, le second paramètre est le paramètre de la remontée, fixé à 150 (pour plus de détails voir la section 2.2.1.2. Recherches locales de type VNS Le paramètre Kmax de VNS est fixé au nombre maximal de variables v × b. Recherche locale GWW Nous avons paramétré GWW avec de nombreuses recherches locales, à savoir IDWalk, taboue et recuit-simulé. Le nombre de particules est fixé à 10. Dans le but d’évaluer la robustesse des méthodes locales appliquées, nous lançons 20 essais sur chaque instance. Les fichiers exécutables et la documentation sont disponible sur le site : https://sites.google.com/site/fzlebbahportfolio. Pour chaque algorithme local appliqué, nous donnons les colonnes suivantes : 4. Nous rappelons qu’une configuration correspond à une instantiation des variables. Dans (P D), une configuration est l’instantiation de la matrice M , où pour tout (i, j), est instantiée par 0 ou 1.

61

succ. : le nombre de succès parmi les 20 essais, temps-moy : le temps moyen sur 20 essais. La première comparaison est faite par rapport aux paramètres déjà cités : succ., et temps-moy. La seconde, en considérant la qualité de la solution obtenue, qui consiste à calculer les colonnes suivantes : moy-λ est la moyenne des chevauchements obtenus, en exploitant la formule ( Pn i=1 o Avgλ = no (3.6) no = v(v−1) nombre de chevauchements 2 Précisément, nous avons exactement v(v − 1)/2 relations de chevauchements, puisque la première ligne représente des chevauchements avec les v − 1 lignes restantes, la seconde avec (v − 2) lignes, et ainsi de suite jusqu’à deux lignes. Ce qui donne no = (v − 1) + (v − 2) + ... + 2 + 1 = v(v − 1)/2 chevauchements à considérer. moy-c est la moyenne des conflits calculée sur 20 essais. 3.9.3 3.9.3.1

Résultats expérimentaux Expérimentation de l’algorithme glouton

Dans le tableau 3.4, nous décrivons le comportement de l’algorithme glouton 8, minimisant le nombre de contraintes violées, en comparaison avec une configuration générée aléatoirement. Dans la configuration générée aléatoirement, nous rapportons l’intervalle des nombres de conflits. Avec l’algorithme 8, nous générons une seule configuration dont le nombre de conflits est donné dans la troisième colonne. Nous remarquons que l’algorithme 8 génère des configurations initiales meilleures : tous les taux de conflits sont considérablement inférieurs à ceux soulevés dans les configurations initiales générées aléatoirement. Dans certaines instances telles que P Dh7, 7, 3, 1i et P Dh10, 8, 3, 2i, notre algorithme fournit des configurations initiales avec 0 conflits. 3.9.3.2

Recherches locales simples

Le tableau 3.5 fournit les résultats du recuit-simulé et de IDWalk en démarrant de deux types de solutions initiailes : – Une solution initiale aléatoire : La colonne SolAléa du tableau 3.5 compare le nombre de succès et le temps moyen des méthodes du recuit-simulé et de IDWalk à partir d’une solution initiale aléatoire. Dans la majorité des instances, le recuit simulé trouve la meilleure solution dans toutes les exécutions dans un temps efficace. Mais IDWalk échoue dans la plupart des instances. Nous avons aussi expérimenté la recherche taboue (où la taille de la liste taboue est fixée à 20), qui n’arrive à résoudre que trois instances : P Dh7, 7, 3, 1i avec 2/20 succès, P Dh10, 8, 3, 2i avec 20/20 et P Dh10, 37, 14, 6i avec 11/20. Nous remarquons que dans la plupart des cas, le recuit-simulé présente un succès total sur les 20 essais. Le recuit simulé demeure plus efficace que IDWalk 62

Table 3.4 – Comparaison du nombre de contraintes violées entre une configuration initiale aléatoire et celle générée par l’algorithme 8. Instance configuration aléatoire configuration gloutonne 7-7-3-1 10 –25 0 8-14-7-3 11 – 27 8 9-18-8-3 24 – 39 17 9-24-8-2 40 – 45 6 9-37-12-3 43 – 45 13 53 – 55 8 10-30-9-2 10-15-6-2 29 – 54 11 10-8-3-2 11 – 35 0 10-25-8-2 51 – 55 9 10-37-14-6 40 – 54 10 10-38-10-2 52 – 55 8 10-33-15-6 34 – 51 10 10-31-22-15 10 – 11 10 10-38-28-20 10 – 10 10 11-11-5-2 28 – 48 13 15-15-4-1 98 – 119 15

en temps d’exécution. Dans la plupart des cas, IDWalk présente des taux de conflit plus élevés que le recuit-simulé. Le tableau 3.6 compare la qualité des résultats calculés avec la formule (3.6), entre Flener et al. et le recuit-simulé. Nous remarquons que la moyenne des chevauchements d’une solution de l’approche de Flener et al. est égale à λ, due à l’utilisation des égalités dans la contrainte de chevauchement du modèle (P D) : toute paire de lignes de la matrice a un taux de chevauchements égal à λ, ce qui implique une moyenne égale à λ. Le recuit-simulé est plus efficace que Flener et al. La majorité des instances résolues, représente une moyenne des chevauchements inférieure à celle obtenue par l’approche de Flener et al. – Une solution initiale gloutonne : La colonne SolInit du tableau 3.5 compare le recuit-simulé avec IDWalk, en démarrant d’une configuration initiale calculée avec l’algorithme glouton 8. Nous remarquons que dans la plupart des cas, IDWalk présente un meilleur succès sur les 20 essais. Nous avons lancé la méthode taboue (avec une liste taboue de longueur 20). Elle n’a réussi à résoudre que trois instances : P Dh7, 7, 3, 1i avec un succès total de 20/20, P Dh10, 8, 3, 2i avec 20/20 et P Dh10, 37, 14, 6 >i avec 20/20. Désormais, la recherche taboue demeure inefficace comparée au recuit simulé et IDWalk. Le recuit-simulé demeure plus efficace que IDWalk en temps d’exécution. Dans quelques cas, IDWalk présente des taux de conflit plus élevés que le recuit-simulé. Le tableau 3.6 compare la qualité des résultats calculés avec la formule 3.6 (voir le début de la section 3.9.2), entre Flener et al. et IDWalk. Dans la colonne de Flener et al., la moyenne (ou la qualité) est égale à la valeur λ (puisque toutes les paires de lignes ont le même taux de chevauchements). Le tableau 3.6 montre clairement que notre approche fournit des solutions avec de meilleurs taux de chevauchements. 63

Table 3.5 – Les temps CPU et les nombres de succès

Instance Inst1 Inst2 Inst3 Inst4 Inst5 Inst6 Inst7 Inst8 Inst9 Inst10 Inst11 Inst12 Inst13 Inst14 Inst15 Inst16

succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy

SolAléa RecSim IDW 20 17 0.00 3.70 20 20 0.00 0.00 20 01 1.73 14.10 20 00 1.15 15.63 00 00 15.52 16.17 19 00 5.33 23.76 08 00 11.43 21.20 19 00 8.38 50.17 20 00 5.44 119.40 10 00 31.96 67.76 18 00 19.36 64.75 20 20 10.84 64.66 20 20 0.01 0.03 20 13 4.14 48.90 00 00 25.60 28.95 02 01 196.76 193.31

64

SolInit RecSim IDW 20 20 0.01 0.00 20 20 0.00 0.00 20 00 4.22 20.70 20 20 4.01 0.02 00 00 23.75 42.23 20 00 7.66 49.75 18 20 12.32 1.61 20 20 15.21 5.47 20 00 14.81 199.84 14 20 44.70 71.43 17 20 37.66 9.66 17 20 36.59 7.02 20 20 0.02 0.02 20 20 11.33 3.22 00 00 44.70 83.61 00 00 199.84 199.92

Table 3.6 – Les taux moyen du nombre de contraintes non-satisfaites et du nombre de chevauchements

Instance Inst1 Inst2 Inst3 Inst4 Inst5 Inst6 Inst7 Inst8 Inst9 Inst10 Inst11 Inst12 Inst13 Inst14 Inst15 Inst16

3.9.3.3

moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ

SolAlea RecSim IDW 0.00 0.20 1.00 0.99 0.00 0.00 1.07 1.08 0.00 2.00 3.00 2.80 0.00 3.75 2.00 1.74 8.00 8.75 0.68 0.63 0.05 2.65 2.00 1.83 0.60 3.15 2.88 2.76 0.05 50.17 1.99 1.92 0.00 1.35 0.86 0.83 0.50 2.30 1.95 1.88 0.10 3.30 1.99 1.92 0.00 2.45 2.97 2.89 0.00 0.00 4.89 4.88 0.00 0.90 1.94 1.94 5.40 7.90 3.48 3.37 1.25 1.95 24.57 24.55

SolInit RecSim IDW 0.00 0.00 1.00 1.00 0.00 0.00 1.00 0.98 0.00 2.00 3.00 2.64 0.00 0.00 2.00 2.00 8.00 8.00 0.63 0.70 0.00 2.00 2.00 1.64 0.10 0.00 2.97 3.00 0.00 0.00 2.00 2.00 0.00 1.00 0.86 0.81 0.30 0.00 1.93 2.00 0.15 0.00 1.97 2.00 0.15 0.00 2.98 2.97 0.00 0.00 4.99 5.00 0.00 0.00 1.94 1.98 3.30 3.00 3.36 3.38 4.50 3.30 24.37 24.33

Flener et al. 1 2 3 2 1 2 3 2 1 2 2 3 6 2 4 26

Étude du paysage de résolution avec recherche locale simple

A travers le tableau expérimental 3.5, nous pouvons distinguer trois types d’instances : Type 1 : Les instances très difficiles, dont la résolution nous mène vers 0 succès, avec un blocage total sur un nombre de conflits. Type 2 : Les instances difficiles, dont la résolution nous permet d’obtenir 0 ou quelques succès sur les 20 essais, mais avec une amélioration (décroissance) lente du nombre de conflits. 65

Type 3 : Les instances très faciles, dont la résolution nous permet d’obtenir un succès absolu (20 succès sur 20 essais). Afin de bien étudier les instances et de déceler l’origine de l’échec et du succès, nous avons pris un échantillon de chaque type d’instances, à savoir P Dh16, 8, 3, 1i, P Dh19, 20, 9, 4i et P Dh9, 37, 12, 3i qui représentent respectivement les types 1, 2 et 3. Ceci afin de réaliser l’étude du paysage (Marmion, 2011)(Marmion et al., 2013) de chacune des instances. Nous avons tracé les courbes 3.2, 3.3 et 3.4 qui décrivent le nombre de conflits en fonction du nombre de mouvements réalisés. En d’autres termes, nous avons le nombre de contraintes violées sur l’axe des ordonnées et le nombre de mouvements réalisés sur l’axe des abscisses. Instance P Dh16, 8, 3, 1i

L’instance P Dh16, 8, 3, 1i peut être considérée très difficile, à travers le nombre de succès nul et le nombre de conflits qui stagne à 8. La résolution de cette instance représente un vrai blocage de la méthode, puisqu’on arrive très tôt au nombre de conflits 8, sans aucune amélioration observée à travers les mouvements réalisés. Dans la figure 3.2, nous représentons en premier lieu une vue globale du paysage 3.2a, puis on donne une vue plus proche de la courbe 3.2b afin de bien étudier le paysage. Dans la figure 3.2a nous remarquons que la courbe décroît rapidement avant d’atteindre 50 mouvements ; nous réussissons à décrémenter le nombre de conflits (dans l’espoir d’atteindre le 0) qui était > 90 à une valeur 6 20, en moins de 50 mouvements. Tout juste après, la courbe devient très accidentée (paysage rugueux), un phénomène qui va s’estomper petit à petit jusqu’à ce qu’on atteint le paysage neutre. Dans la figure 3.2b, nous arrivons à bien analyser la courbe qui est lisse au début, puis rugueuse avant de devenir neutre en atteignant le nombre de conflits 8, une courbe neutre qui met en avant le problème du minima local. Instance P Dh19, 20, 9, 4i

Nous prenons comme exemple l’instance P Dh16, 8, 3, 1i ayant fournit 0 succès mais avec une variation des degrés de violation entre les 20 essais. Dans la figure 3.3, nous représentons en premier la totalité du paysage 3.3a, puis on donne une vision plus agrandie de la courbe 3.2b afin de bien analyser le paysage. Nous pouvons déceler le même phénomène de décroissance de la courbe dans la figure 3.3a, en allant d’un nombre de conflits > 130 vers 20 conflits en moins de 100 mouvements. Nous marquons après sur la figure 3.3b une courbe lisse puis rugueuse jusqu’à ce qu’elle devint neutre. C’est un cas souffrant du problème du minima local. Instance P Dh9, 37, 12, 3i

En dernière position nous prenons l’instance P Dh9, 37, 12, 3i qui donne 20 succès sur les 20 essais, en un temps raisonnable. Nous illustrons dans la figure 3.4 le paysage des solutions allant de 45 conflits jusqu’à 0 conflits (toutes les contraintes sont vérifiées). Nous relevons dans la figure 3.4a, une courbe plus ou moins neutre au début, puis une convergence rapide de 45 conflits vers 5 conflits en 100 mouvements seulement. 66

(a) Le paysage de l’instance P Dh16, 8, 3, 1i en démarrant avec une solution ayant plus de 90 de conflits

(b) Le paysage de l’instance P Dh16, 8, 3, 1i en démarrant avec une solution ayant plus de 10 de conflits

Figure 3.2 – Le paysage de l’instance P Dh16, 8, 3, 1i

Nous illustrons dans la figure 3.4b une vision plus proche de la courbe après avoir atteint 5 conflits. Nous relevons un paysage lisse qui reflète une exploration de bonne qualité et par conséquent une méthode bien adaptée à la résolution de l’instance. Finalement, on peut conclure que l’échec de la méthode sur une instance peut être relevé sur des parties des courbes représentant des paysages neutres. Un phénomène 67

(a) Le paysage de l’instance P Dh19, 20, 9, 4i en démarrant avec une solution presque 140 conflits

(b) Le paysage de l’instance P Dh19, 20, 9, 4i en démarrant avec une solution ayant plus de 20 de conflits

Figure 3.3 – Le paysage de l’instance P Dh19, 20, 9, 4i

qui peut être expliqué par des vallées très profondes (problème de l’optimum local), ce qui exige une augmentation du degré d’exploration. Une augmentation qui peut décroître la qualité des résultats dans le cas des paysages lisses. Nous pensons qu’une gestion plus réfléchie de la particularité de chaque partie du paysage doit donner de meilleurs résultats. En d’autres termes, proposer une procédure d’exploration 68

(a) Le paysage de l’instance P Dh9, 37, 12, 3i en démarrant avec une solution de 45 conflits

(b) Le paysage de l’instance P Dh9, 37, 12, 3i en démarrant avec une solution ayant presque 5 de conflits

Figure 3.4 – Le paysage de l’instance P Dh9, 37, 12, 3i

adaptée à la particularité de chaque phase de résolution de l’instance. 69

3.9.3.4

Recherche locale avec voisinage variable

Cette section expose les résultats expérimentaux sur les différentes variantes VNS sur les instances (P D), avec les algorithmes 10 et 11 (VNSPD et SVNSPD) en utilisant le récuit-simulé (sim-ann) (Kirkpatrick et al., 1983a) et l’algorithme IDWalk (idw) (Neveu et al., 2004). Nous avons expérimenté les stratégies VNS suivantes : 1. VNS basique avec recuit-simulé et la fonction de voisinage flip : VSF 2. VNS basique avec recuit-simulé et la fonction de voisinage swap : VSS 3. VNS basique avec IDW et la fonction de voisinage flip : VIF 4. VNS basique avec IDW et la fonction de voisinage swap : VIS 5. Skewed VNS avec recuit-simulé et la fonction de voisinage flip : SSF 6. Skewed VNS avec recuit-simulé et la fonction de voisinage swap : SSS 7. Skewed VNS avec IDW et la fonction de voisinage flip : SIF 8. Skewed VNS avec IDW et la fonction de voisinage swap : SIS

70

Table 3.7 – Résultats expérimentaux en temps et en nombre de succès

VNSPD Instance

Inst1 Inst2 Inst3 Inst4 Inst5 Inst6 Inst7 Inst8 Inst9 Inst10 Inst11 Inst12 Inst13 Inst14 Inst15 Inst16

succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy

RecSim Flip Swap VSF VSS 20 20 0.00 0.00 20 20 0.00 0.00 20 20 2.34 1.51 20 20 1.24 2.27 00 00 199.66 199.77 20 20 5.29 1.70 17 20 50.18 9.35 20 20 7.78 10.96 20 20 5.55 8.87 17 20 62.50 47.49 20 10 20.19 143.43 20 20 10.77 9.39 20 20 0.01 0.01 20 20 4.99 5.92 00 00 199.70 199.73 13 00 193.08 199.77

IDW Flip Swap VIF VIS 20 20 7.51 0.01 20 20 0.00 0.00 03 20 182.96 0.25 03 20 169.80 0.34 00 00 199.76 199.71 19 20 5.57 4.89 00 20 199.72 5.52 01 20 199.05 7.64 04 20 163.85 1.69 00 18 199.75 72.75 18 08 20.05 162.07 20 20 11.10 1.73 20 20 0.07 0.00 12 20 84.60 0.21 00 00 199.72 199.80 01 00 195.98 199.75

SVNSPD RecSim IDW Flip Swap Flip Swap SSF SSS SIF SIS 20 20 20 20 0.01 0.01 10.41 0.01 20 20 20 20 0.00 0.00 0.00 0.00 20 20 02 20 2.66 1.54 189.90 0.12 20 20 01 20 1.35 2.20 196.64 1.10 00 00 00 00 199.83 193.85 199.83 199.83 20 20 00 20 10.33 6.27 199.84 3.04 20 20 00 20 47.70 10.66 199.84 6.40 20 20 00 20 12.69 14.97 199.84 6.46 20 20 20 20 0.00 0.00 0.00 0.00 20 15 00 18 93.55 111.11 199.82 67.78 20 05 00 06 62.79 167.38 199.80 151.28 20 20 01 20 17.67 9.48 199.59 1.91 20 20 20 20 0.02 0.01 0.11 0.01 20 20 08 20 8.27 5.93 126.07 0.21 00 00 00 00 199.81 199.81 199.65 199.65 01 00 00 00 199.18 199.81 199.63 199.77

La Table 3.7 rapporte les performances des algorithmes VNSPD et SVNSPD en considérant les deux fonctions de voisinage. VNS et SVNS avec le récuit-simulé fournissent les meilleures combinaisons. Les instances Inst5, Inst15 et Inst16 sont les instances les plus difficiles. VNS avec le récuit-simulé et la fonction flip est la seule méthode à réussir la résolution de l’instance Inst16 dans de nombreuses exécutions. Nous pouvons aussi noté que SVNS avec le récuit-simulé et la fonction swap est la combinaison la plus robuste, car elle a réussi dans toutes les exécutions, à l’exception des trois instances Inst5, Inst15 et Inst16. Finalement, nous pouvons conclure que 71

la méthode VNS avec le récuit simulé et la fonction flip est la combinaison la plus efficace. Table 3.8 – moy-c and moy-λ results

Instance

Inst1 Inst2 Inst3 Inst4 Inst5 Inst6 Inst7 Inst8 Inst9 Inst10 Inst11 Inst12 Inst13 Inst14 Inst15 Inst16

moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ

VNSPD RecSim IDW Flip Swap Flip Swap VSF VSS VIF VIS 0.00 0.00 0.00 0.00 1.00 1.00 1.00 1.00 0.00 0.00 0.00 0.00 1.08 1.08 1.09 1.08 0.00 0.00 1.30 0.00 3.00 3.00 2.82 3.00 0.00 0.00 2.25 0.00 2.00 2.00 1.75 2.00 7.95 8.00 8.60 8.00 0.68 1.00 0.67 1.00 0.00 0.00 0.05 0.00 2.00 2.00 1.84 2.00 0.15 0.00 2.20 0.00 2.95 3.00 2.80 3.00 0.00 0.00 1.80 0.00 2.00 2.00 1.91 2.00 0.00 0.00 1.05 0.00 0.75 0.68 0.76 0.76 0.15 0.00 2.10 0.10 1.97 2.00 1.92 2.00 0.00 0.50 0.10 0.60 2.00 2.00 1.94 2.00 0.00 0.00 0.00 0.00 2.97 2.97 2.87 2.96 0.00 0.00 0.00 0.00 4.87 4.90 4.91 4.88 0.00 0.00 0.80 0.00 1.94 1.93 1.88 1.93 4.90 2.85 7.25 2.85 3.50 3.82 3.40 3.84 1.55 4.35 1.75 2.85 24.59 24.89 24.53 24.83

SVNSPD RecSim IDW Flip Swap Flip Swap SSF SSS SIF SIS 0.00 0.00 0.00 0.00 1.00 1.00 1.00 1.00 0.00 0.00 0.00 0.00 1.07 1.08 1.09 1.09 0.00 0.00 1.20 0.00 3.00 3.00 2.97 3.00 0.00 0.00 2.50 0.00 2.00 2.00 1.81 2.00 8.00 8.00 8.50 8.00 0.72 1.04 0.70 1.04 0.00 0.00 2.45 0.00 2.00 2.00 1.92 2.00 0.00 0.00 2.30 0.00 3.00 3.00 2.87 3.00 0.00 0.00 2.30 0.00 2.00 2.00 2.00 2.00 0.00 0.00 0.00 0.00 0.07 0.68 0.07 0.73 0.00 0.30 2.90 0.10 1.99 2.00 1.95 2.00 0.00 0.75 3.15 0.70 2.00 2.00 2.00 2.00 0.00 0.00 3.00 0.00 2.97 2.97 2.93 2.96 0.00 0.00 0.00 0.00 4.80 4.90 4.87 4.66 0.00 0.00 1.05 0.00 1.93 1.94 1.94 1.93 4.60 3.15 7.65 3.10 3.50 3.84 3.42 4.83 1.70 4.35 3.70 2.85 24.52 25.00 24.37 24.79

λ

1 2 3 2 1 2 3 2 1 2 2 3 6 2 4 26

Concernant les résultats relativement à moy-λ, notons que dans l’approche exacte de Flener et al., moy-λ est constamment égal à λ, car elle utilise le modèle avec égalité (i.e., Mi,j Mt,j = λ in (P D)). Dans la plupart des instances, le nombre moyen de chevauchements des approches VNS avec le récuit-simulé est strictement inférieur à λ. Ceci montre que notre approche VNS résout mieux le problème original 72

(P D). Il y a seulement deux instances P Dh16, 8, 3, 1i et h19, 20, 9, 4i qui n’ont pas été résolues, mais leur nombre de contraintes non-satisfaites est bas (resp. 7.95 et 4.65) comparativement au nombre de contraintes (resp. 136 et 190). En plus, dans les exécutions non-réussies fournissant des solutions approchées, nous remarquons que le nombre de chevauchements, même si strictement supérieur à λ, il reste très proche de λ. Dans l’instance I5 ayant 136 contraintes, toutes les combinaisons ont réussi à atteindre seulement huit contraintes non-satisfaites et le nombre moyen de chevauchements est très proche de λ = 1. Concernant l’instance Inst15 avec ses 190 contraintes, VNS avec le récuit-simulé et la fonction swap a réussi à avoir en moyenne 2.85 contraintes non-satisfaites et le nombre moyen de chevauchements inférieur à λ = 4. Avoir un nombre moyen de chevauchement bas dans les exécutions non-réussies, est une propriété intéressante pour la robustesse de la méthode. 3.9.3.5

Méthode à population GWW

Dans cette section, nous donnons les résultats expérimentaux de la méthode GWW combinée avec le recuit-simulé (colonne GRecSim), avec IDWalk (colonne GIDW) et avec IDWalk combiné avec taboue (colonne GIDWTab). Le tableau 3.10 (resp. 3.9) établit les performances en nombre de succès et en temps (resp. en nombre moyen de contraintes insatisfaites et en nombre moyen de chevauchements).

73

Table 3.9 – Les temps CPU et les nombres de succès

Instance Inst1 Inst2 Inst3 Inst4 Inst5 Inst6 Inst7 Inst8 Inst9 Inst10 Inst11 Inst12 Inst13 Inst14 Inst15 Inst16

succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy succ. /20 temps-moy

GRecSim 20 1.29 20 0.00 05 107.56 15 165.43 00 199.66 00 199.65 01 189.01 01 199.05 00 199.65 00 199.66 00 199.64 00 199.65 20 0.04 00 199.65 00 199.64 00 199.65

74

GWW GIDW GIDWTab 20 20 0.61 28.297 20 20 0.00 0.00 13 01 106.84 190.53 16 03 90.37 183.24 00 00 199.60 199.62 04 00 168.71 199.63 03 00 194.59 199.63 09 00 133.28 199.63 12 00 130.95 199.64 00 00 199.64 199.64 02 00 190.98 199.63 16 15 97.10 91.35 20 20 0.10 0.80 20 20 13.67 59.54 00 00 199.64 199.63 02 00 184.06 199.64

Table 3.10 – Les taux moyens des nombres de contraintes et des chevauchements

Instance Inst1 Inst2 Inst3 Inst4 Inst5 Inst6 Inst7 Inst8 Inst9 Inst10 Inst11 Inst12 Inst13 Inst14 Inst15 Inst16

moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ moy-c moy-λ

GRecSim 1.28 1.00 0.00 1.06 0.80 2.88 0.30 1.97 8.00 0.69 1.45 1.88 1.70 2.80 1.80 1.81 3.15 0.78 2.65 1.75 3.10 1.72 2.15 2.59 0.00 4.85 2.15 1.69 9.70 3.05 6.20 20.17

GWW GIdw GIDWTab 00 00 1.00 1.00 0.00 0.00 1.07 1.07 0.35 1.90 2.99 2.75 0.20 1.55 1.98 1.82 8.00 8.05 0.66 0.58 0.80 3.00 1.94 1.73 1.25 2.45 2.92 2.77 0.65 1.95 1.97 1.92 0.40 1.60 0.82 0.83 1.00 2.20 1.91 1.85 1.50 3.30 1.94 0.83 0.20 0.25 2.95 2.96 0.00 0.00 4.83 4.93 0.00 0.00 1.94 1.95 5.15 7.05 3.50 3.36 1.65 10.10 24.55 24.36

Flener et al. 1 2 3 2 1 2 3 2 1 2 2 3 6 2 4 26

La combinaison GWW avec IDWalk est plus performante que GWW avec recuitsimulé et GWW avec IDWalk combiné avec taboue. En somme, les performances des différentes combinaisons restent inférieures aux performances des recherches locales simples et des recherches locales à voisinage variable. On peut déduire : – La stratégie qui consiste à changer de voisinage systématiquement est plus payante que de faire travailler de nombreuses recherches locales. 75

– Les recherches locales simples donnent de meilleurs résultats si on les laisse fonctionner plus longtemps. En effet, GWW partage le temps alloué entre de nombreuses recherches, pénalisant les recherches locales qui ont besoin de plus de temps pour converger vers la solution. Ces deux remarques sont déduites relativement au temps limite de 200 secondes. Cependant, vues les performances des recherches locales simples, augmenter le temps limite permettra éventuellement d’avoir de meilleurs succès pour la méthode GWW, mais ne pourra pas rendre GWW plus performante en temps. 3.9.4

Étude des profiles de performance

Dans cette section, nous avons mis en œuvre différents types de méthodes locales, avec différentes solutions de démarrage et différentes fonctions de voisinage. Nous avons testé chaque approche sur 16 instances, avec 20 essais lancés sur chacune. Afin de pouvoir réaliser une bonne synthèse des performances des différentes approches réalisées, nous utilisons le profile de performance proposé dans (Dolan et Moré, 2002)(Fontaine, 2013). Soient p un ensemble de problèmes, et M un ensemble de méthodes désignées à les résoudre. Soit pi ∈ P un problème et mj ∈ M une méthode pour résoudre pi . Considérons t une mesure, dont t(pi , mj ) évalue la performance de la méthode mj pour résoudre le problème pi en fonction de t. Le rapport de performance r(pi , mj ) compare la performance de la méthode mj avec celle de la meilleure méthode qui résout pi . La plus petite valeur t(pi , mj ) représente la meilleure qualité de la méthode. Définition 3.9.1 (Le rapport de performance) (Dolan et Moré, 2002) r(pi , mj ) =

t(pi , mj ) min{t(pi , mk )|mk ∈ M }

(3.7)

Si r(pi , mj ) = 1, alors mj est la meilleure méthode pour résoudre le problème pi . Soit τmax le plus grand des rapports calculés r(pi , mj ). Afin dévaluer la performance de toutes les méthodes dans M sur les problèmes P , nous utilisons la performance fractionnelle ρmj : [1, τmax ] → [0, 1]. Définition 3.9.2 (La performance fractionnelle de la méthode mj ) ρmj (τ ) =

|pi ∈ P : r(pi , mj ) 6 τ | |P |

(3.8)

ρmj (τ ) est la fraction des problèmes dans P tels que mj est apte à résoudre avec un facteur τ > 1 pour la meilleure méthode. Par conséquent, les méthodes ayant la plus grande valeur ρmj (τ ) seront les meilleures. Dans les figures 3.5, 3.6 et 3.7, nous exposons les courbes qui décrivent les profiles de performance des méthodes implantées, par rapport au nombre de succès et par rapport au temps d’exécution. Pour l’axe horizontal (l’axe des rapports de performance), nous utilisons une échelle logarithmique pour avoir une meilleure distinction entre les courbes de la même figure. Dans la figure ci-dessous 3.5, nous exposons une évaluation via le pourcentage de performance des méthodes locales simples, notées par RLS, par rapport au nombre de succès et au temps d’exécution. Nous désignons les approches comme suit : 76

AléaRS : Le recuit simulé lancé avec une solution initiale générée aléatoirement. AléaIDW : La méthode IDWalk lancée avec une solution initiale générée aléatoirement. GloutRS : Le recuit simulé lancé avec une solution initiale calculée avec l’algorithme glouton 8. GloutIDW : La méthode IDWalk lancée avec une solution initiale calculée avec l’algorithme glouton 8. Nous décrivons les deux illustrations 3.5a et 3.5b contenues dans la figure 3.5 comme suit : La figure 3.5a analyse les nombres de succès réalisés par chacune des méthodes. Ceci en traçant les courbes respectives via le pourcentage de performance. La figure 3.5b analyse les temps CPU réalisés par chacune des méthodes. Ceci en traçant les courbes respectives via le pourcentage de performance.

77

(a) Les nombres de succès.

(b) Les temps CPU.

Figure 3.5 – Profile de performance-RLS en fonction des nombres de succès et en en fonction des Temps CPU

Dans la figure 3.5a : – Nous remarquons, via la courbe de GloutIDW l’amélioration réalisée sur la méthode IDWalk quand elle est lancée avec une solution initiale calculée avec notre algorithme glouton. – Au début, la meilleure méthode à considérer en nombre de succès est le recuit simulé avec une solution de démarrage calculée avec l’algorithme glouton. – Vers la fin, nous constatons la méthode Recuit Simulé qui prend l’élan en nombre de succès, par rapport au reste des méthodes. Concernant la figure 3.5b, nous remarquons que la méthode IDWalk avec une 78

solution initiale gloutonne est plus performante que celle lancée avec une solution initiale aléatoire. D’ailleurs, c’est la plus performante au départ, mais vers la fin c’est le Recuit Simulé qui l’emporte, avec les deux versions : solution initiale aléatoire et solution initiale gloutonne, à savoir BloutRS et AléaRS. La figure 3.6 décrit l’évolution du nombre de succès et du temps CPU, relativement aux approches à voisinage variable implantées. Nous désignons par : VRF : La méthode VNS combinée avec le Recuit Simulé lancée avec la fonction de voisinage Flip. VRS : La méthode VNS combinée avec le Recuit Simulé lancée avec la fonction de voisinage Swap. VIF : La méthode VNS combinée avec IDWalk lancée avec la fonction de voisinage Flip. VIS : La méthode VNS combinée avec IDWalk lancée avec la fonction de voisinage Swap. SRF : La méthode SVNS combinée avec le Recuit Simulé lancée avec la fonction de voisinage Flip. SRS : La méthode SVNS combinée avec le Recuit Simulé lancée avec la fonction de voisinage Swap. SIF : La méthode SVNS combinée avec IDWalk lancée avec la fonction de voisinage Flip. SIS : La méthode SNS combinée avec IDWalk lancée avec la fonction de voisinage Swap. La figure 3.6 comporte deux parties : La figure 3.6a analyse les nombres de succès réalisés par chacune des méthodes, ceci en traçant les courbes respectives via les profiles de performance. La figure 3.6b analyse les temps CPU réalisés par chacune des méthodes, ceci en traçant les courbes respectives via les profiles de performance.

79

(a) Les nombres de succès.

(b) Les temps CPU.

Figure 3.6 – Profile de performance-VNS/SVNS en fonction des nombres de succès et en en fonction des Temps CPU

Les courbes 3.6a illustrées dans 3.6, peuvent être décrites en trois points : – La méthode SRF démarre avec les meilleures performances, avant que la méthode l’emporte tout juste après, pour devenir la plus performante en nombre de succès. – Vers la fin, nous remarquons une amélioration de SRF pour qu’elle devienne aussi performante que VRF. Relativement à la figure 3.6b, nous relevons le succès marqué par la méthode SIS, pour qu’elle soit la meilleure en temps d’exécution au démarrage. Mais la méthode notée par VRF devient plus performante (plus rapide) vers la fin. 80

Les tableaux expérimentaux 3.9 et 3.10 qui exposent les résultats obtenus via l’approche à population (voir la section 3.9), ont mis en avant la méthode GWW combiné avec la méthode IDW. Pour avoir une synthèse plus générale des approches incomplètes appliquées, nous avons pris les deux meilleures méthodes des catégories : RS (Recherche locale Simple) et VNS (en deux versions : basique et biaisée), en plus de la méthode GWW+IDwak (notée par GIDW. Nous regroupons les courbes qui illustrent les profiles de performances (en nombre de succès et en temps CPU) dans la figure 3.7. Les illustrations 3.7a et 3.7b décrivent respectivement l’évolution des nombres de succès et les temps d’exécution.

(a) Les nombres de succès.

(b) Les temps CPU.

Figure 3.7 – Profiles de performance des méthodes performantes en fonction des nombres de succès et en en fonction des Temps CPU 81

Par rapport au nombre de succès, la figure 3.7a met en avant la méthode VRF par rapport au reste des méthodes. Comme nous pouvons percevoir la déficience de la méthode à population GIDW (GWW combinée avec IDWalk). La figure 3.7b peut être décrite en trois points : – Initialement, elle montre l’avantage de la méthode SIS en temps d’exécution, par rapport au reste des méthodes. – Puis, on remarque la méthode AléaRS qui devient la plus performante. Mais la méthode GloutRS devient aussi rapide (performante) que AléaRS. – Comme nous pouvons constater la lenteur de la méthode GIDW. A travers les 6 figures de courbes illustrées ci-dessus, nous pouvons conclure en moyenne que la méthode VRF est la plus adaptée en nombre de succès à notre problème P D. Par contre, les méthodes SIS, AléaRS et GloutRS sont les plus performantes en nombre de succès

3.10

Conclusion

Dans ce chapitre, nous avons détaillé l’application des méthodes incomplètes sur le problème (P D). Nous avons proposé une méthode gloutonne qui permet de produire une solution d’une meilleure qualité par rapport à des solutions choisies aléatoirement. En effet, les recherches locales simples ont produit de meilleurs résultats en démarrant de la solution initiale gloutonne, par rapport à des solutions choisies aléatoirement. Les performances des recherches locales se sont nettement améliorées en adoptant des voisinages variables dans le contexte des algorithmes VNS. Cependant, l’adoption d’une méthode à population n’a pas permis d’améliorer réellement les performances. En somme, les expérimentations entreprises ont montré que la méthode du recuitsimulé a produit les meilleures performances soit dans sa version simple ou dans sa version à voisinage variable.

82

Chapitre 4

Méthodes exactes pour le problème de conception de portefeuilles 4.1

Introduction

Dans ce chapitre nous appréhendons le problème de conception des portefeuilles (P D) avec des approches complètes, à savoir la Programmation Linéaire en Nombres Entiers PLNE et la Programmation Par Contraintes PPC. Plus particulièrement, le modèle (P D) que nous étudions, considère les contraintes originales de chevauchements sous forme d’inégalités ; contrairement au modèle de Flener et al. qui adopte la forme avec égalités. Plus globalement, nous avons de nombreux objectifs : – Nous voulons considérer directement le modèle avec inégalités pour pouvoir produire des solutions avec un meilleur taux de chevauchement. – Étudier les performances des modélisations en PLNE et en PPC. – Alors que le modèle de Flener et al. considère seulement les symétries ligne et colonne, on voudrait considérer d’autres types de symétries, notamment les symétries rotationnelles. – Étudier l’apport des techniques dynamiques d’élimination de symétries. Dans la section précédente 3.2, nous avons exposé un modèle matriciel (3.1) de forme quadratique défini sur des variables 0 − 1. Nous proposons une linéarisation de ce modèle afin de pouvoir faire appel aux solveurs PLNE. Les techniques d’élimination de symétries issues de la PPC ont eu un grand succès dans l’accélération de la résolution des systèmes de contraintes. Justement, nous proposons aussi d’enrichir notre modèle PLNE avec des contraintes qui permettent d’éliminer les symétries ligne et colonne via une approche statique. Nous proposons une deuxième formulation du modèle précédent (3.1) sous forme d’un problème de satisfaction de contraintes, permettant ainsi d’exploiter les techniques de la PPC et faire appel aux solveurs PPC. Nous résolvons le problème (P D) sans et avec prise en considération des symétries présentes dans le modèle. Les deux modèles PLNE et PPC ont été implémentés dans les deux environnements SCIP (Achterberg, 2009) et GECODE (Schulte et Stuckey, 2008). Nous avons expérimenté ces deux modèles sur les instances étudiées dans le chapitre précédent, afin de montrer l’apport pratique des méthodes complètes dans la résolution des instances du problème de conception des portefeuilles. 83

4.2

Exemple de motivation

Dans cette section, nous illustrons l’apport des méthodes complètes via l’approche PPC sur le modèle (P D) avec des inégalités. Considérons l’instance h10, 8, 3, 2i que nous résolvons avec le solveur Gecode en intégrant la technique d’élimination de symétries LDSB sur le modèle avec inégalités. Dans le tableau 4.1, nous montrons les deux solutions sur le modèle avec égalité et le modèle avec inégalités. La paire de lignes en gras contient deux chevauchements, alors que les deux lignes en gras/italique contient un seul chevauchement. Table 4.1 – Les deux solutions générées pour P Dh10, 8, 3, 2i, en appliquant l’approche de Flener et al. sur le modèle avec égalité et l’approche PPC sur le modèle avec inégalités Modèle avec égalités 01011000 10010010 10011000 01000011 10001100 10000110 01001010 00101001 01000101 01101000

Modèle avec inégalités 00000111 00001011 00001101 0 0 0 0 1 1 1 0 0 0 0 1 0 0 1 1 00010101 00010110 00011001 00011010 00011100

La résolution de l’instance P Dh10, 8, 3, 2i avec l’approche de Flener et al. donne une solution dont toutes les paires de lignes représentent deux chevauchements. Par contre, avec l’application de l’approche PPC sur le modèle original avec inégalité, nous obtenons des taux de chevauchements compris dans l’intervalle [1, 2]. Comme illustré dans la Table 4.2, la solution du modèle original avec inégalités a un taux moyen de chevauchement meilleur que le modèle avec égalités de Flener et al. Table 4.2 – La moyenne des chevauchements de l’instance P Dh10, 8, 3, 2i

Le taux moyen de chevauchement

Modèle avec égalités 2.00

Modèle avec inégalités 1.67

Dans la suite du document, nous allons voir que le modèle PPC intégrant les symétries permet d’améliorer nettement les performances de l’approche de Flener et al. sur de nombreuses instances du problème, en considérant les inégalités ; les solutions obtenues ont un taux de chevauchement meilleur permettant une plus grande diversification des portefeuilles. 84

4.3

Approche basée sur la Programmation en Nombres Entiers (PLNE)

La programmation linéaire (PL) (Bisschop, 2006) a été développée au début de l’ère de la programmation mathématique. Elle demeure la plus utilisée dans le domaine de l’optimisation des modèles à contraintes, en raison de l’existence d’une vaste théorie, la disponibilité des méthodes efficaces de résolution, et l’applicabilité de la programmation linéaire sur de nombreux problèmes pratiques. La programmation linéaire en nombres entiers est un sous-domaine de la PL, avec des variables de décisions de type entier. 4.3.1

Linéarisation du modèle (P D)

Dans cette section, nous montrons le procédé de linéarisation de la contrainte quadratique de chevauchements. En fait, les techniques de linéarisation (Sherali et Adams, 1999; Sahinidis et Twarmalani, 2002) ont été pleinement développées en recherche opérationnelle afin de ramener des problèmes non-linéaires vers des modèles linéaires profitant des solveurs performants de la programmation linéaire. En appliquant une linéarisation classique (voir par exemple (Bisschop, 2006)) destinée à des contraintes quadratiques définies sur des variables binaires, nous obtenons le modèle linéaire (4.1) donné par la proposition suivante. Proposition 4.3.1 On considère un problème d’optimisation de portefeuilles financiers P Dhv, b, r, λi défini par le modèle quadratique (3.1). La reformulation linéaire du modèle 3.1 est donnée par :  P =r ∀i ∈ 1..v,  j∈1..b M  Pi,j  b   ∀i ∈ 1..v, ∀k > i, j=1 Zikj ≤ λ     ∀i ∈ 1..v, ∀j ∈ 1..b, Mi,j ∈ {0, 1} P Dlin hv, b, r, λi ∀i ∈ 1..v, ∀k > i, Zikj ≤ Mij (4.1)    ∀i ∈ 1..v, ∀k > i, Z ≤ M ikj kj     ∀i ∈ 1..v, ∀k > i, Z ≥ M ikj ij + Mkj − 1   ∀i ∈ 1..v, ∀j ∈ 1..b, ∀k, Zikj ∈ {0, 1} Preuve Soient les contraintes quadratiques  P ∀i ∈ 1..v, ∀t > i, bj=1 Mi,j Mk,j ≤ λ avec Mi,j , Mt,j ∈ {0, 1}

(4.2)

qui expriment la relation de chevauchement. Soit la variable supplémentaire Zikj ∈ {0, 1}, telle que Zikj = Mi,j × Mk,j . Les contraintes linéaires (4.3) forcent la variable Zikj à prendre la valeur du produit Mij × Mkj :   Zikj ≤ Mij Zikj ≤ Mkj (4.3)  Z ≥M +M −1 ikj ij kj 85

On peut facilement démontrer que le système (4.3) est équivalent à la contrainte Zikj = Mi,j × Mk,j . Il suffit de vérifier que ces deux systèmes ont les mêmes solutions en énumérant les huit cas de la table de vérité de la formule Zikj = Mi,j × Mk,j . En remplaçant le produit Mi,j × Mk,j par la variable Zikj et en introduisant les contraintes (4.3) de linéarisation, on obtient le modèle linéaire (4.1) 2 Le modèle linéaire (5.1) donné ci-dessus regroupe : • v(v−1) b variables de linéarisation plus vb variables du modèle quadratique, ce 2 2 qui donne v(v−1) b + vb, soit v b+vb au total. 2 2 3 • 2 (v(v − 1)b contraintes de linéarisation et v + v(v−1) contraintes du modèle 2 (1+3b)v 2 +(1−3b)v initial, ce qui donne au total contraintes. 2 4.3.2

Élimination des symétries sur le modèle linéaire

Le problème (P D) discuté précédemment, contient deux types de symétries, à savoir : les symétries lignes et les symétries colonnes. Dans cette section, nous exploitons la sémantique particulière de notre problème, afin d’éliminer les symétries ligne et colonne, directement liée aux contraintes ligne et colonne. L’élimination de symétries opérera en ajoutant des contraintes linéaires au modèle (4.1). Justement, la prise en compte des symétries ligne et colonne s’effectuera en utilisant la contrainte d’ordre lexicographique 6Lex décrite dans la section 2.4. La proposition 4.3.2 exprime le modèle (4.4) qui enrichit le modèle linéaire (4.1) avec deux contraintes d’élimination de symétries. Proposition 4.3.2 Considérons le modèle linéaire (4.1) ; L’application de l’élimination de symétries 6Lex sur les lignes et les colonnes du problème P D, donne le modèle linéaire suivant :

P Dlin−Lex hv, b, r, λi

                          

P ∀i ∈ 1..v, j∈1..b Mi,j = r P ∀i ∈ 1..v, ∀k > i, bj=1 Zikj ≤ λ ∀i ∈ 1..v, ∀k > i, Zikj ≤ Mij ∀i ∈ 1..v, ∀k > i, Zikj ≤ Mkj ∀i ∈ 1..v, ∀k > i, Zikj ≥ Mij + Mkj − 1 ∀i ∈ 1..v, ∀j ∈ 1..b, Mi,j ∈ {0, 1} ∀i ∈ 1..v, ∀j ∈ 1..b, ∀k, Zikj ∈ {0, 1} P P ∀i ∈ 1..v − 1, bj=1 Mi,j .2(j−1−b) ≤ bj=1 Mi+1,j .2(j−1−b) P P ∀j ∈ 1..b − 1, vi=1 Mi,j .2(i−1−v) ≤ vi=1 Mi,j+1 .2(i−1−v) (4.4)

Preuve Soit M la matrice v × b de variables 0 − 1 manipulées dans le modèle (4.1). Toute permutation entre une ligne quelconque et une autre ligne quelconque garde intactes les solutions du modèle (P D). De même, permuter une colonne et une autre colonne préserve l’ensemble des solutions. En conséquence, étant donnée une solution du problème, on peut obtenir les autres solutions symétriques en permutant les lignes et/ou les colonnes. 86

Nous supposons que Mi,1..b et Mi+1,1..b sont les deux vecteurs représentant les deux lignes successives d’indices i et i + 1 de M . De même sur les colonnes, soient M1..v,j et M1..v,j+1 les deux vecteurs représentant les deux colonnes successives de M . En appliquant la relation d’ordre lexicographique 6Lex que nous avons introduit dans la section 4.4.2, on aura : ∀i ∈ 1..v − 1, Mi,1..b 6Lex Mi+1,1..b ∀j ∈ 1..b − 1, M1..v,j 6Lex M1..v,j+1

(4.5) (4.6)

Injecter ces deux types de contraintes dans le modèle évitera de trouver les solutions symétriques au niveau lignes et/ou colonnes. On doit démontrer que les deux contraintes (4.5) et (4.6) sont respectivement équivalentes aux deux contraintes ajoutées du modèle (4.4) : ∀i ∈ 1..v − 1, ∀j ∈ 1..b − 1,

b X j=1 v X

(j−1−b)

Mi,j .2

≤

Mi,j .2(i−1−v) ≤

i=1

b X j=1 v X

Mi+1,j .2(j−1−b)

(4.7)

Mi,j+1 .2(i−1−v)

(4.8)

i=1

Par le fait que les variables Mi,j sont binaires, les deux ordres lexicographiques (4.5) et (4.6) peuvent être traduits numériquement vers les deux contraintes (4.7) et (4.8). L’inverse est aussi vrai. 2 Le nombre de contraintes ajoutées pour éliminer les symétries ligne et colonne est (v − 1) + (b − 1) qui est négligeable par rapport au nombre de contraintes contenues dans le P L initial (4.1). Dans la section expérimentale de ce chapitre, la table 4.3 montre clairement que le nombre de contraintes ajoutées dans les instances étudiées est négligeable.

4.4 4.4.1

Approche PPC Modélisation du problème (P D) en PPC

En se basant sur le catalogue des contraintes globales proposées dans (Beldiceanu et al., 2007), nous reformulons le modèle (3.1) sous forme d’un CSP, que nous introduisons dans la proposition 4.4.1. Proposition 4.4.1 Le modèle (P D) exprimé dans la formulation (3.1) est équivalent au CSP :   X = {Xi,j | i ∈ 1..v, j ∈ 1..b} ∪ {Pi,t,j | i ∈ 1..v, j ∈ 1..b, i < t 6 b}     DXi,j = DPi,t,j = {0, 1}, avec i ∈ 1..v, j ∈ 1..b et i < t 6 b c1 : LIN EAR(RowX (i), =, r), ∀i ∈ 1..v CSPP D   c2 : AN D(Pi,t,j , (Xij , Xt,j ))∀i ∈ 1..v, ∀t > i, ∀j ∈ 1..b    c : LIN EAR(P {j = 1..b}, ≤, λ), ∀i ∈ 1..v, ∀t > i 3 i,t,j (4.9) 87

Le CSP proposé CSPP D comporte la matrice des variables X et la matrice des variables de réification P . Nous avons fait appel à deux contraintes globales connues en P P C : 1. La contrainte globale LIN EAR, dont la syntaxe est LIN EAR(V ECT EU R, CT R, V AL) où V ECT EU R est le vecteur dont on veut sommer les composantes, CT R ∈ {, =, 6, >}. La relation CT R doit être vérifiée entre le résultat de la somme calculée et la valeur désignée par V AL. RowX (i) désigne la ligne i de la matrice X. 2. La contrainte globale AN D dont la syntaxe est AN D(V AR, V ARIABLES) où V ARIABLES est une suite de variables 0-1 : V AR1 , V AR2 , ..., V ARn (n ≥ 2) et V AR est une variable définie par l’égalité V AR = V AR1 ∧ V AR2 ∧ ...V ARn . En fait, les contraintes c1 , c2 et c3 expriment la forme usuelle :  P  c1 : j∈1..b Xi,j = r, ∀i ∈ 1..v c2 : Pi,t,j = Xi,j Xt,j , ∀i ∈ 1..v, ∀t > i, ∀j ∈ 1..b  c :P 3 j∈1..b Pi,t,j ≤ λ, ∀i ∈ 1..v, ∀t > i La contrainte c1 exprime la contrainte ligne du modèle (P D). La contrainte c3 exprime la contrainte de chevauchement en fonction du vecteur P résultant de la multiplication des paires de lignes. 4.4.2

Symétries dans le problème (P D)

Comme nous l’avons déjà évoqué dans le modèle PLNE, le problème (P D) contient des symétries ligne et colonne. Ces symétries ont été exprimées avec un codage numérique explicité dans la proposition 4.3.2. Définition 4.4.2 (Symétrie sémantique du problème (P D)) Soit P le modèle 3.1 décrivant le problème (P D) et M sa matrice correspondante. La symétrie sémantique de P est une permutation σ des Mij telle que P et σ(P ) ont le même ensemble de solutions. Définition 4.4.3 (Symétrie syntaxique du problème (P D)) Soit P le modèle 3.1 décrivant le problème (P D) et M sa matrice correspondante. Une symétrie syntaxique de P est une permutation σ des Mij telle que P = σ(P ). Proposition 4.4.4 Toute symétrie syntaxique de P est une symétrie sémantique de P . Preuve Il est trivial de voir que la symétrie syntaxique est une condition suffisante pour la symétrie sémantique. En effet, si σ est une symétrie syntaxique de P , alors P = σ(P ), donc il en résulte que P et σ(P ) ont les mêmes modèles. Ainsi, P et σ(P ) ont le même ensemble de solutions. Par conséquent toute symétrie syntaxique est une symétrie sémantique et en général, l’inverse n’est pas vérifié. 2 88

Proposition 4.4.5 La symétrie ligne dans le problème (P D) est une symétrie syntaxique. Preuve Soit M la matrice solution de taille v × b du problème (P D). Pour montrer syntaxiquement que (P D) admet une symétrie ligne, nous devons prouver que la matrice M lg obtenue après : – permutation de deux lignes quelconques, – et le reste des variables restent inchangées, vérifie les contraintes ligne et de chevauchement du problème (P D). Les contraintes ligne :   0 Soient RowM (i) = [V0 , V1 , ..., Vb−1 ] et RowM (i0 ) = V00 , V10 , ..., Vb−1 les lignes respectives i et i0 de la matrice solution M . En appliquant une permutation sur les lignes RowM (i) et RowM (i0 ), et en laissant le reste des lignes inchangées, nous la matrice M lg avec RowM lg (i0 ) = [V0 , V1 , ..., Vb−1 ] et  obtenons  0 RowM lg (i) = V00 , V10 , ..., Vb−1 . Puisque M est une matrice solution, les contraintes ligne : P M =r P j∈1..b i,j j∈1..b Mi0 ,j = r sont vérifiées. Nous avons RowM lg (i0 ) = RowM (i) et RowM lg (i) = RowM (i0 ), ce qui donne les deux contraintes ligne par rapport à M lg : P lg j∈1..b Mi0 ,j = r P lg j∈1..b Mi,j = r vérifiées. Par conséquent, la permutation de n’importe quelle paire de lignes dans une matrice solution génère une matrice solution préservant la consistance des contraintes ligne. Les contraintes de chevauchement : Puisque la matrice M est une matrice solution, alors : – le chevauchement entre la ligne i et une ligne quelconque de M est 6 λ, – et le chevauchement entre la ligne i0 et une ligne quelconque de M est 6 λ. Sachant que RowM (i) = RowM lg (i0 ) et RowM (i0 ) = RowM lg (i), nous constatons que la matrice Mlg résultant de la permutation représente : – le chevauchement entre la ligne i0 et une ligne quelconque de M lg est 6 λ, – et le chevauchement entre la ligne i et une ligne quelconque de M lg est 6 λ. Ainsi, les contraintes de chevauchement sont vérifiées dans la matrice M lg . Par conséquent, la permutation de n’importe quelle paire de lignes d’une matrice solution de P D, génère une matrice solution préservant la consistance de l’ensemble des contraintes. Ce qui implique que le problème (P D) contient une symétrie ligne. 2 Proposition 4.4.6 La symétrie colonne dans le problème (P D) est une symétrie syntaxique. 89

Preuve Soit M la matrice solution de taille v × b résolvant le problème (P D). Pour dire que M admet une symétrie colonne, nous devons montrer que la matrice M cl résultant après : – permutation de deux colonnes quelconques, – et le reste des variables invariant, respecte les contraintes ligne et de chevauchement du problème P D. Les contraintes ligne :   0 Soient ColM (c) = [V0 , V1 , ..., Vb−1 ] et ColM (c0 ) = V00 , V10 , ..., Vb−1 , avec c < c0 , les colonnes respectives c et c0 de la matrice solution M . En appliquant une permutation sur les colonnes ColM (c) et ColM (c0 ), et en laissant le reste des cocl 0 lonnes invariantes, obtenons  0 nous  la matrice M avec colM cl (c ) = [V0 , V1 , ..., Vb−1 ] 0 0 et colM cl (c) = V0 , V1 , ..., Vb−1 . Puisque M est une matrice solution, les contraintes ligne : P ∀i ∈ 1..v, j∈1..b Mi,j = r sont vérifiées, alors : P P P ∀i ∈ 1..v, j∈1..c−1 Mi,j + Mi,c + j∈c+1..c0 −1 Mi,j + Mi,c0 + j∈c0 +1..b Mi,j = r sont vérifiées. En remplaçant les éléments de la matrice M par ceux de la matrice Mcl , nous obtenons l’écriture suivante : P P P cl cl cl =r + Mi,c + j∈c0 +1..b Mi,j + Mi,c0 + j∈c+1..c0 −1 Mi,j ∀i ∈ 1..v, j∈1..c−1 Mi,j ce qui est équivalent à : ∀i ∈ 1..v,

P

j∈1..b

cl =r Mi,j

Par conséquent, la permutation de deux colonnes dans la matrice solution, donne toujours une solution. Les contraintes de chevauchement : Puisque M est une matrice solution, les contraintes de chevauchement : P ∀i ∈ 1..v, ∀t > i, bj=1 Mi,j Mt,j ≤ λ sont vérifiées. Ce qui peut s’exprimer comme suit : ∀i ∈ 1..v, ∀t > i, Pc0 −1 Pb j=1 Mi,j Mt,j + Mi,c Mt,c + j=c+1 Mi,j Mt,j + Mi,c0 Mt,c0 + j=c0 +1 Mi,j Mt,j ≤ λ

Pc−1

En remplaçant les éléments de la matrice M par ceux de la matrice M cl , nous obtenons les contraintes suivantes : Pc−1

cl cl j=1 Mi,j Mt,j

∀i ∈ 1..v, ∀t > i, Pc0 −1 P cl cl cl cl + Mi,c0 Mt,c0 + j=c+1 Mi,j Mt,j + Mi,c Mt,c + bj=c0 +1 Mi,j Mt,j ≤λ

Ce qui est équivalent à : ∀i ∈ 1..v, ∀t > i,

Pb

j=1

cl cl Mi,j Mt,j ≤λ

Ce qui implique que les contraintes de chevauchement sont toujours vérifiées dans la matrice Mcl . 90

Par conséquent, la permutation de n’importe quelle paire de colonnes d’une matrice solution de P D, génère une matrice solution préservant la consistance de l’ensemble des contraintes. Ce qui implique que le problème (P D) contient une symétrie colonne. 2 En PPC, on peut éliminer ces symétries directement en faisant appel à la contrainte globale d’ordre lexicographique : Définition 4.4.7 Soient deux vecteurs X et Y de taille n : X = [X0 , ..., Xn−1 ] Y = [Y0 , ..., Yn−1 ] On dit que le vecteur X est lexicographiquement plus petit ou égal à Y , noté par X 6Lex Y , si et seulement si X0 < Y0 ou (X0 = Y0 et [X1 , ..., Xn−1 ] 6Lex [Y1 , ..., Yn−1 ]) Des symétries traitées par la relation d’ordre lexicographique (ou anti-lexicographique) entre les lignes et entre les colonnes, que nous décrirons en détail dans les soussections suivantes. En plus de ces deux symétries ligne et colonne, déjà évoquées dans la section PLNE, nous introduirons une autre symétrie détectée sur notre problème : la symétrie syntaxique de rotation de 180˚ décrite dans la proposition suivante. Proposition 4.4.8 Le problème de conception des portefeuilles (P D) décrit par le modèle 3.1 contient une symétrie syntaxique de rotation de 180˚. Preuve Soit M la matrice de taille v × b résolvant le problème (P D). Soit M 180 la matrice obtenue après une rotation de 180˚. En fait, M 180 est obtenue à partir de M en appliquant les opérations suivantes : 1. Permutations des lignes : Dans la matrice M , on permute la ligne v − 1 avec la ligne 0, la ligne v − 2 avec la ligne 1, ..., la ligne v/2 avec la ligne [si v est pair alors (v + 2)/2 sinon (v + 3)/2]. En appliquant ces v/2 permutations, on obtient la matrice intermédiaire M 0 . 2. Permutations des colonnes : Dans la matrice M 0 , on permute la colonne b − 1 avec la colonne 0, la colonne b − 2 avec la colonne 1, ..., la colonne b/2 avec la colonne [si b est pair alors (b + 2)/2 sinon (b + 3)/2]. En appliquant ces b/2 permutations, on obtient la matrice intermédiaire M 00 . 3. La matrice M 00 est évidemment la matrice M 180 2 En somme, nous disposons de trois symétries dans le modèle (P D) : ligne, colonne et rotationnelle de 180˚. En PPC, trois techniques ont été développées pour implémenter les symétries : statique, dynamique et mixte. Pour plus de détails sur ces trois techniques, nous renvoyons le lecteur à la section 2.4. En se basant sur le modèle CSPP D , nous avons opté pour trois stratégies pour implémenter l’élimination des trois symétries : 1. L’élimination des symétries ligne et colonne statiquement en utilisant l’ordre lexicographique (Flener et al., 2002, 2009). Ceci en intégrant deux contraintes supplémentaires dans CSPP D . 91

2. L’élimination des symétries ligne et colonne d’une manière dynamique, en adoptant la méthode LDSB (Mears et al., 2014) décrite dans la section 2.5.2. 3. L’élimination des symétries ligne et colonne via la méthode Lex et LDSB, ceci en appliquant : – la relation 6Lex sur les lignes (ou sur les colonnes). – la méthode LDSB pour éliminer les symétries au niveau des colonnes (ou au niveau des lignes). 4. En dernière position, nous introduisons la symétrie rotationnellle de 180˚, pour la traiter avec LDSB. Élimination statique des symétries Comme nous l’avons indiqué précédemment dans la section 2.4, une cassure de symétries statique implique l’intégration de contraintes supplémentaires au CSP modélisant le problème, pour exprimer l’ordre lexicographique entre les lignes et entre les colonnes. Ce qui donne dans notre cas CSPP DLEX comme suit : CSPP D CSPP DLEX c4 : LEX_GREAT EREQ(RowX (i), RowX (i + 1)), ∀i ∈ 1..v − 1 c5 : LEX_GREAT EREQ(ColumnX (j), ColumnX (j + 1)), ∀j ∈ 1..b − 1 (4.10) CSPP DLEX alimente le modèle CSPP D avec deux contraintes supplémentaires pour l’élimination des symétries ligne et colonne. Ces deux contraintes ajoutées font appel à la contrainte globale LEX_GREAT EREQ dont la syntaxe est : LEX_GREAT EREQ(V ECT EU R1 , V ECT EU R2 ) pour exprimer la relation V ECT EU R1 >Lex V ECT EU R2 Par conséquent, nous avons les contraintes : c4 : LEX_GREAT EREQ(RowX (i), RowX (i + 1)), ∀i ∈ 1..v − 1, qui exprime la relation RowX (i) > RowX (i + 1) avec RowX (i) et RowX (i + 1) qui désignent respectivement la ime ligne et et la i + 1me ligne de X. c5 : LEX_GREAT EREQ(ColumnX (j), ColumnX (j + 1)), ∀j ∈ 1..b − 1 qui exprime la relation ColumnX (j) > ColumnX (j+1) avec ColumnX (j) et ColumnX (j+ 1) qui désignent respectivement la j me colonne et et la j + 1me colonne de X. Élimination dynamique des symétries Nous allons aussi faire appel à la méthode dynamique LDSB d’élimination des symétries. Son apport sera mis en avant dans la partie expérimentale de ce chapitre.

4.5

Etude expérimentale

Nos expérimentations ont été lancées sur une machine ayant la configuration : Linux-ubuntu 12.04, Intel CPU E5-2603 et 8 GB/RAM avec un temps limite de 3600 secondes. 92

4.5.1

4.5.1.1

Approche PLNE

L’environnement SCIP

SCIP (Constraint Integer Programming (CIP)) (Achterberg, 2005; Achterberg et al., 2008a,b) est un environnement logiciel destiné pour la programmation linéaire en nombres entiers intégrant finement la notion de contrainte. SCIP propose un nouveau paradigme qui intègre pleinement les techniques PLNE et des techniques de la PPC. Le code source du solveur SCIP est accessible pour usage académique et non-commercial scip.zib.de. L’approche exploitée dans la réalisation du solveur SCIP diffère des travaux qui l’ont précédé par rapport au niveau de l’intégration. SCIP combine les techniques se la PPC, SAT et PLNE au plus bas niveau de la plate-forme. En particulier, tous les algorithmes de recherche opèrent sur un seul arbre de recherche, qui permet une interaction étroite entre ces techniques. Par exemple, les composantes de la PLNE peuvent utiliser des heuristiques de décision qui se basent sur des statistiques, recueillies par des algorithmes de la PPC ou vice versa. Les deux paradigmes PLNE et PPC peuvent utiliser l’information duale fournie par le PL après relaxation du sous-problème en cours. En d’autres termes, SCIP permet d’exploiter différents algorithmes de différentes techniques, à savoir : – la propagation des domaines des variables par des algorithmes spécifiques appliqués sur les contraintes, – la résolution des programmes linéaires PL après relaxation du modèle représentant le problème, – le renforcement du modèle PL avec les techniques de Branch & Cut, – l’analyse des sous-problèmes irréalisables pour déduire une connaissance globale et utilisation de l’instance traitée du problème. L’idée de combiner les techniques de modélisation et de résolution issues de la PPC et de la PLNE n’est pas nouvelle. De nombreux auteurs ont montré qu’une approche intégrée peut aider dans la résolution des problèmes d’optimisation qui était insolubles avec une seule méthode.

4.5.1.2

Résultats expérimentaux

Le tableau 4.3 décrit chaque instance par ses paramètres et le nombre de variables qu’elle contient. Pour chacun des modèles (4.1) et (4.4), nous introduisons via les colonnes respectives PD-SCIP et PD-SCIP-Lex le nombre de contraintes qu’il regroupe ainsi que les temps CPU réalisés. 93

Table 4.3 – Les résultats expérimentaux obtenus avec SCIP Instance h7,7,3,1i h10,8,3,2i h8,14,7,3i h11,11,5,2i h16,8,3,1i h10,15,6,2i h9,18,8,3i h9,24,8,2i h15,15,4,1i h10,25,8,2i h10,30,9,2i h9,37,12,3i h10,37,14,6i h10,38,10,2i h19,20,9,4i h15,350,100,25i

Nbe-Var 196 440 504 726 1088 825 810 1080 1800 1375 1650 1665 2035 2090 3800 42000

PD-SCIP Nbe-Const Temps-Exe 469 1.67 1135 >3600 1212 33.53 1881 47.50 3016 >3600 2080 178.92 1989 96.22 2637 304.33 4845 >3600 3430 1860.47 4105 2658.31 4041 1260.36 5050 588.80 5185 6204.09 10450 >3600 110370 >3600

PD-SCIP-Lex Nbe-Const Temps-Exe 481 0.14 1151 91.51 1232 32.18 1901 191.03 3038 14.77 2130 229.39 2014 320.75 2668 313.74 4873 >3600 3463 >3600 4143 >3600 4085 >3600 5095 >3600 5231 >3600 10487 >3600 110733 >3600

Nous constatons que la colonne PD-SCIP montre l’échec de SCIP dans la résolution de quelques instances. Avec l’élimination des symétries lignes et des symétries colonnes, il y a seulement deux instances nouvellement résolues, et qui étaient insolvables sans élimination de symétries. Cependant, de nombreuses instances qui étaient résolues sans éliminations de symétries, n’ont pas été résolues en intégrant les symétries. La Figure 4.1 illustre l’évolution des temps CPU sous l’environnement SCIP en fonction du nombre de variables des instances, pour la résolution du modèle (4.1) et (4.4), désignés respectivement par les courbes PD et PD-Lex.

Figure 4.1 – Comparaison des temps CPU réalisés sous SCIP avec et sans élimination de symétries, en fonction du nombre de variables des instances 94

D’après la Figure 4.1 qui contient les temps CPU réalisés sur les instances résolues en moins d’une heure avec la PL, nous constatons que les deux PLs (4.1) et (4.4) sont très proches en temps d’exécution jusqu’à ce qu’on arrive à l’instance Inst6 où on observe la divergence de la courbe -PD-Lex-, ce qui reflète la lourdeur de l’élimination des symétries en PL. 4.5.2 4.5.2.1

Approche PPC Environnement GECODE

Gecode est un environnement de développement des systèmes et des applications basés sur les contraintes (Schulte et al., 2010). C’est un outil open-source http://www.gecode.org/, accessible et efficace pour la résolution des problèmes combinatoires. Il propose une bibliothèque riche en modélisation, contenant les techniques de propagation, de filtrage, d’élimination de symétries, etc. Le point fort du solveur est la possibilité d’accéder à son code source et pouvoir intégrer : – de nouveaux algorithmes de propagation, – de nouvelles stratégies de branchement, – un nouveau moteur de recherche, – de nouveaux types de variables, etc. Pour plus de détails, nous renvoyons le lecteur aux références (Schulte, 2002; Schulte et Tack, 2006; Reischuk et al., 2009). 4.5.2.2

Résultats expérimentaux

L’implémentation des différents CSPs (e.g., CSPP D , CSPP DLEX ) avec ou sans élimination des différentes symétries a été réalisée dans l’environnement Gecode. Dans le tableau 4.4, nous introduisons les temps CPU obtenus via les différentes implémentations réalisées, à savoir : 1. Résolution de CSPP D (4.9) sans aucune prise en considération des trois symétries. Elle est notée par PD. 2. Résolution de CSPP DLEX (4.4) avec élimination des symétries ligne et colonne avec la méthode Lex. Elle est notée par PDLex. 3. Résolution de CSPP D (4.9) avec élimination des symétries ligne et colonne avec la méthode LDSB. Elle est notée par PDSym2LDSB. 4. Résolution du CSP avec élimination des symétries lignes avec la méthode Lex et des symétries colonnes avec la méthode LDSB. Elle est notée par PDLexLDSB. 5. Résolution de CSPP D (4.9) avec élimination des trois symétries avec la méthode LDSB. Elle est notée par PDSym3LDSB. La première colonne de la table expérimentale 4.4 introduit les instances traitées, dans l’ordre croissant par rapport au nombre de variables. Les colonnes 2, 3, 4 et 5 introduisent les temps CPU réalisés par les trois types de résolutions citées ci-dessus. 95

Table 4.4 – Les résultats expérimentaux obtenus avec Gecode Instance h7,7,3,1i h10,8,3,2i h8,14,7,3i h11,11,5,2i h16,8,3,1i h10,15,6,2i h9,18,8,3i h9,24,8,2i h15,15,4,1i h10,25,8,2i h10,30,9,2i h9,37,12,3i h10,37,14,6i h10,38,10,2i h19,20,9,4i h15,350,100,25i

PD 0.001 0.002 0.089 0.027 >3600 8.641 6.955 1.298 350.293 182.292 9.945 >3600 524.930 35.067 10.571 >3600

PDLex 0.001 0.004 2.744 1.354 >3600 39.468 2009.371 3269.871 >3600 >3600 >3600 >3600 >3600 >3600 >3600 >3600

PDSym2LDSB 0.001 0.003 0.018 0.013 >3600 0.071 0.156 0.086 2.173 1.362 1.045 >3600 84.055 2.093 8.914 >3600

PDLexLDSB 0.001 0.001 0.049 0.020 >3600 0.476 0.955 1.043 0.318 11.276 8.168 >3600 522.907 49.140 5.376 >3600

PDSym3LDSB 0.001 0.003 0.031 0.025 >3600 0.147 0.321 0.178 4.683 2.994 2.173 >3600 90.353 2.248 9.224 >3600

La première remarque qu’on peut prononcer sur le tableau 4.4, est l’échec de l’application de l’élimination des deux symétries (ligne et colonne) avec la méthode Lex à résoudre la moitié des instances en moins d’une heure. Ceci est dû à la nature partielle de la méthode Lex (voir la section 2.5.1). Nous constatons que la résolution avec une élimination de symétries de type LDSB donne des résultats meilleurs que les deux autres cas. Pour la comparaison entre les méthodes les plus rentables : PD, PDSym2LDSB, PDLexLDSB et PDSym3LDSB, nous introduisons la figure 4.2. Dans cette dernière, nous analysons quatre implémentations par rapport au temps CPU sur les instances résolues en un temps inférieur ou égal à une heure.

Figure 4.2 – Comparaison des temps CPU réalisés avec les différentes implémentations PPC, en fonction du nombre de variables des instances 96

A travers les courbes tracées sur la Figure 4.2, nous émettons deux conclusions : 1. Les courbes -PD- et -PDLexLDSB- qui représentent respectivement la résolution sans élimination de symétries et avec élimination mixte (statique/dynamique) de symétries, sont beaucoup moins stables que les autres. 2. L’application de LDSB pour éliminer – les deux symétries ligne et colonne PDSym2LDSB, désignée par la courbe -PDSym2LDSB-, – les trois symétries lignes, colonnes et celle de rotation de 180˚PDSym3LDSB, désignée par la courbe -PDSym3LDSB-, donne de meilleurs résultats par rapport aux temps d’exécution avec des courbes stables. Par conséquent, on peut déduire que l’élimination de symétries avec la méthode LDSB est très rentable. Le fait d’intégrer le troisième type de symétries (la symétrie rotationnelle de 180˚) ne ralentit pas le processus de résolution du problème (P D). Tout au contraire : la symétrie rotationnelle a permis d’améliorer les temps d’une façon notable.

4.5.3

Synthèse des résultats

Dans la Table 4.5, nous introduisons dans les colonnes 2 et 3 les temps CPU réalisés avec les meilleures mises en ouvre sous SCIP et sous Gecode à savoir : PD-SCIP et PDSym3LDSB et ceux de Flener et al. Dans la quatrième colonne nous introduisons les temps d’exécution avec le type de modèle adopté dans (Flener et al., 2007) : le modèle ensembliste avec simplification des contraintes de chevauchement et/ou le modèle BIBD correspondant au problème (P D). Sachant que les expérimentations de (Flener et al., 2007) ont été réalisées sur une machine avec un processeur AMD Athlon XP 2400+ qui est plus lent que notre machine (Intel CPU E5-2603) avec un facteur 8 1 En somme, le temps de l’approche de Flener et al. doit être divisé par 8.

1. Voir le benchmarking des processeurs disponible sur le site http://www.cpubenchmark.net/ singleThread.html. L’indice de performances du processeur AMD Athlon XP +2400 est 462, et celui du processeur Intel CPU E5-2603 est 3765.

97

Table 4.5 – Les meilleurs résultats expérimentaux obtenus avec l’approche exacte Instance h7,7,3,1i h10,8,3,2i h8,14,7,3i h11,11,5,2i h16,8,3,1i h10,15,6,2i h9,18,8,3i h9,24,8,2i h15,15,4,1i h10,25,8,2i h10,30,9,2i h9,37,12,3i h10,37,14,6i h10,38,10,2i h19,20,9,4i h15,350,100,25i

SCIP (PDLex) 1.67 >3600 33.53 47.50 >3600 178.92 96.22 304.33 >3600 1860.47 2658.31 1260.36 588.80 6204.09 >3600 >3600

Gecode (PDSym3LDSB) 0.00 0.00 0.03 0.03 >3600 0.15 0.32 0.18 4.68 3.00 2.173 >3600 90.35 2.25 9.22 >3600

Flener et al. 0.00(PD) -(PD) | 00.00(BIBD) 0.01(PD) 0.00(PD) 0.52(PD) 0.01(BIBD) | 0.76(PD) 0.01(BIBD) | 0.25(PD) 28.62(PD) 0.02(PD) 0.01(BIBD) | 373(PD) 3.05(PD) 0.16(PD) 0.62(PD) 0.16(BIBD) | >3600(PD) >3600

Nous introduisons via la Figure 4.3, deux courbes -PD- et -PDSym3LDSB- qui désignent respectivement la résolution sous l’environnement SCIP sans élimination de symétries et la résolution sous l’environnement Gecode avec l’élimination des trois types de symétries. Ces deux courbes introduisent les temps CPU réalisés sur les instances résolues en un temps inférieur ou égal à une heure.

Figure 4.3 – Comparaison des meilleurs temps CPU réalisés sous Gecode et SCIP en fonction du nombre de variables des instances

Nous remarquons la divergence de la courbe -PD- à partir de l’instance Inst6, 98

et la stabilité de la courbe -PDSym3LDSB- et dont les temps CPU réalisés sont raisonnables.

4.6

Conclusion

Dans ce chapitre nous avons introduit les deux approches exactes adoptées pour appréhender le problème P D : la programmation linéaire en nombres entiers (PLNE) et la programmation par contraintes (PPC). Notre problème est fortement symétrique. Flener et al. ont exploité les symétries ligne et colonne détectées dans le problème ensembliste (P D) avec égalités. Nous avons formalisé ces symétries dans un cadre matriciel sur le domaine 0-1. Nous avons introduit la symétrie rotationnelle de 180˚, renforçant plus la prise en compte des symétries du problème. Nous avons linéarisé le modèle quadratique (P D), nous permettant ainsi de faire appel aux solveurs PLNE. Nous avons intégré les symétries ligne et colonne dans le modèle linéarisé. Par la suite, nous avons présenté le modèle PPC du problème (P D). Ensuite nous avons introduit les deux types d’élimination de symétries statique et dynamique à travers les méthodes respectives Lex et LDSB. En dernière position nous avons proposé une approche d’hybridation entre les méthodes d’élimination statique via Lex et d’élimination dynamique via LDSB. Nous avons expérimenté l’ensemble de tous les modèles PPC et PLNE présentés, nous permettant de tirer les conclusions suivantes : 1. L’intégration des contraintes d’élimination des symétries ligne et colonne en PLNE n’accroît pas vraiment le nombre de contraintes. Le modèle PLNE avec élimination de symétries n’a pas amélioré notablement les performances du PL initial. Cependant, certaines instances qui étaient insolvables sans élimination de symétries, ont été résolues grâce à l’intégration des symétries. 2. L’élimination des symétries avec LDSB, appliquée sur CSPP D s’avère beaucoup plus efficace par rapport à la PLNE et les autres types d’éliminations de symétries.

99

100

Conclusions et perspectives Dans cette thèse, nous avons appréhendé le problème de conception des portefeuilles, issu de l’ingénierie des finances noté P D (Portfolio Design). C’est un problème qui a été formulé sous forme d’un modèle ensembliste simplifié et abordé par (Flener et al., 2007) avec une approche systématique basée sur les techniques de la Programmation Par Contraintes (PPC). L’objectif principal de ce travail est de résoudre le problème P D sans simplification, afin de concevoir des portefeuilles de meilleure qualité, et en un temps raisonnable. Ceci en utilisant différentes techniques de résolution : approchées (incomplètes) et exactes (complètes) via différents environnements de modélisation. Dans ce chapitre, nous commençons par un rappel de nos contributions, puis nous présentons les conclusions générales de notre travail. Finalement, nous terminons avec des perspectives.

Rappel des contributions Notre premier apport était de proposer un modèle matriciel qui reflète exactement le problème de conception des portefeuilles P D. Ce modèle est fortement combinatoire, car il comprend de nombreuses contraintes quadratiques sur le domaine 0-1. Sa résolution est un véritable défi aux méthodes courantes de résolution de contraintes. En parallèle, nous exploitons la borne inférieure du taux de chevauchement proposée par (Flener et al., 2007). En premier lieu, nous avons opté pour les méthodes approchées (dites locales), avec l’objectif de minimiser le nombre de contraintes violées. Nous avons proposé deux fonctions de voisinage qui tiennent compte de la sémantique des contraintes : flip : Elle permet d’inverser la valeur de la variable qui représente le maximum de conflits et le minimum de fois où elle a été choisie. Elle a été conçue pour le modèle matriciel, avec le risque de violer les contraintes lignes et les contraintes de chevauchement. swap : Elle permet de permuter les contenus de deux variables de valeurs différentes, et qui appartiennent à la même ligne de la matrice. Nous l’avons conçu avec omission des contraintes ligne dont la consistance est toujours conservée. Pour la fonction flip, nous avons proposé une fonction d’évaluation (incrémentale) qui calcule le nombre de contraintes (ligne et colonne) violées. Par contre, nous avons défini une autre fonction d’évaluation qui n’évalue que le nombre les contraintes de chevauchement pour la fonction swap, puisqu’elle garde toutes les contraintes ligne vérifiées. Nous avons pu appliquer des méthodes locales de trois catégories différentes : 101

Les méthodes locales simples : (Lebbah et Lebbah, 2015a) nous avons appliqué trois approches, à savoir le recuit simulé, IDWalk et la méthode taboue, en deux versions : avec une solution initiale aléatoire et avec une solution initiale calculée. Les méthodes locales à voisinage variable : nous avons mis en œuvre la méthode VNS basique (Lebbah et Lebbah, 2015b) et la méthode VNS biaisé (appelée skewed VNS et notée SVNS). Les méthodes locales à population : (Lebbah et Lebbah, 2012) nous avons appliqué la méthode GWW. Concernant les méthodes simples, nous avons proposé un algorithme glouton qui calcule la solution initiale (solution de démarrage). Cet algorithme nous a permis de démarrer avec une solution initiale calculée et qui représente moins de conflits (contraintes violées) par rapport à une solution initiale générée aléatoirement. Nous avons réalisé les différentes mises en œuvre sous l’environnement opensource INCOP, un outil qui a été conçu pour le traitement des CSP linéaires et les CSP pondérées, disposant des méthodes locales du recuit simulé, de IDWalk, de la méthode taboue et de la méthode à population GWW. Nous avons implémenté sous INCOP de nouvelles classes et de nouvelles méthodes, afin d’y intégrer le traitement des CSPs n-aires, des méthodes à voisinage variable et des différentes fonctions de voisinage et des fonctions d’évaluation. Ce qui nous a permis d’expérimenter convenablement l’ensemble des méthodes proposées. Pour évaluer expérimentalement les méthodes approchées proposées, nous avons introduit au niveau de chacune des trois catégories, des tableaux expérimentaux qui mettent en avant l’apport de chaque méthode à travers différents critères (e.g., le temps d’exécution, le nombre de succès, le nombre de conflits et la moyenne des taux de chevauchement). Nous avons par la suite intégré des courbes de performance, afin de déceler la ou les méthode(s) de meilleures performances. Suite à nos propositions des méthodes approchées, nous avons abordé notre problème avec les méthodes complètes, en puisant dans la PLNE (Programmation Linéaire en Nombres Entiers) et la PPC. Suite à la nature quadratique de notre modèle matriciel, nous avons proposé une reformulation linéaire exacte du modèle initial. Pour exploiter la nature fortement symétrique de notre problème, nous avons proposé et intégré des contraintes linéaires pour casser les symétries ligne et colonne. Par la suite, nous avons expérimenté notre modèle PLNE avec et sans cassure de symétries, en exploitant le solveur open-source SCIP. Enfin nous avons fait appel aux techniques de la PPC. Nous avons introduit le CSP correspondant au modèle matriciel via des contraintes globales connues en PPC (Beldiceanu et al., 2007). Les symétries ligne et colonne sont deux symétries détectées par (Flener et al., 2007), et résolues avec une technique de cassure de symétrie statique, basée sur l’addition de contraintes qui impose l’ordre lexicographique entre les lignes et/ou les colonnes. Nous avons détecté une nouvelle symétrie, dite symétrie de rotation de 180˚. Par la suite, nous avons exploité les techniques de cassure de symétrie statique et dynamique. Plus précisément, nous avons appliqué les méthodes Lex (pour l’ordre lexicographique)(Flener et al., 2002) et LDSB (Lightweight Dynamic Symmetry Breaking) (Mears et al., 2014). La mise en œuvre a été réalisée sous l’environnement open-source Gecode, qui nous a permis de traiter notre problème 102

de différentes manières : 1. sans cassure de symétrie, 2. en appliquant une cassure des symétries ligne et colonne avec la méthode Lex (méthode statique), 3. en appliquant une cassure des symétries ligne et colonne avec la méthode LDSB (méthode dynamique), 4. en appliquant une cassure de symétrie mixte : Lex sur la symétrie ligne et LDSB sur la symétrie colonne, 5. en prenant en considération la symétrie rotationnelle, nous avons appliqué la méthode LDSB pour briser les trois types de symétries (ligne, colonne et rotationnelle de degré 180˚). Nous avons finalisé ces mises en œuvres avec des tableaux expérimentaux et des courbes comparatives, afin de bien étudier et analyser les instances traitées.

Les conclusions Le problème d’optimisation des portefeuilles financiers est un problème critique qui peut être généralisé vers d’autres domaines en dehors de la finance. Le modèle matriciel que nous avions proposé, par le fait qu’il respecte exactement les contraintes imposées par le problème, nous a permis d’avoir des portefeuilles de qualité nettement meilleurs en un temps raisonnable. La mise en place de notre algorithme glouton pour la génération de la solution initiale, a permis aux méthodes locales simples d’améliorer les résultats obtenus en temps d’exécution et en taux de succès, à l’exception de la méthode taboue qui demeure inefficace. Cet algorithme, donne la possibilité aux méthodes locales simples de démarrer avec une solution initiale dont le nombre de conflits (contraintes violées) incontestablement diminué par rapport à une solution générée aléatoirement. L’application des méthodes locales VNS et SVNS à voisinage variable avec les deux fonctions de voisinage Flip et Swap, a permis la proposition de nombreuses méthodes locales simples. Les méthodes à voisinage variable réalisées avec le recuitsimulé, ont permis d’avoir une meilleure qualité des portefeuilles. La combinaison avec le recuit-simulé et la fonction de voisinage Swap a produit les solutions qui ont le plus petit taux de conflits. Concernant la méthode à population, nous constatons que la combinaison GWWIDWalk est plus performante que GWW-Recuit-simulé. Cette approche à population, appliquée sur notre problème s’est avérée moins performante que les approches adoptant le changement systématique du voisinage. En somme, on peut déduire que : – Les performances des recherches locales simples et des recherches locales à voisinage variable demeurent les meilleures. – La méthode GWW partage le temps alloué entre de nombreuses recherches, pénalisant les recherches locales qui ont besoin de plus de temps pour converger vers la solution. Cette conclusion expérimentale doit être relativisée au temps limite de 200 secondes. A propos des approches complètes, nous constatons que : 103

– L’intégration des contraintes de cassure des symétries ligne et colonne dans le modèle PLNE a permis d’améliorer légèrement les performances de ce modèle. – La cassure des symétries avec LDSB appliquée sur le modèle PPC, s’avère beaucoup plus performante par rapport au modèle PLNE, ainsi que le modèle PPC intégrant la cassure statique des symétries. – Globalement, les temps CPU réalisés avec la PPC se sont révélés très compétitifs. Nos solutions constituent des portefeuilles de meilleures qualités par rapport à celles de Flener et al. en raison de notre prise en compte des contraintes d’inégalité.

Les perspectives Dans cette thèse nous avons appréhendé le problème de conception des portefeuilles avec différentes approches et différentes techniques, ce qui nous a permis d’étudier et d’analyser le problème de différents angles. En conséquence, nous pouvons exprimer de nombreuses perspectives afin de poursuivre le présent travail : 1. Nous prospectons la résolution de notre problème avec une approche parallèle appliquée sur une méthode incomplète à population. Ce qui nous permettra d’augmenter le nombre de particules et d’exploiter profondément la notion de population. 2. Nous voulons étudier l’opportunité pour hybrider les recherches locales proposées, notamment avec des méthodes d’apprentissage permettant de choisir la bonne recherche locale par rapport à la nature du paysage. 3. Nous voudrons étudier et analyser les instances difficiles, à paysages neutres ou rugueux, afin de détecter la particularité de ces instances qui les rend dures à résoudre. Ceci pour pouvoir les aborder avec une approche meilleure avec des propositions algorithmiques qui tirent encore plus profit de la sémantique particulière du modèle (P D). 4. Les méthodes à voisinage variable se sont avérées les plus efficaces. Par conséquent, nous avons la perception de pouvoir réaliser de meilleures performances via des améliorations à réaliser sur la mise en œuvre de ces méthodes. Nous estimons, qu’il est possible de générer une version parallélisée avec une bonne synchronisation entre les différentes étapes de génération des voisinages. 5. Nous pensons que les méthodes complètes méritent encore plus d’investissements. Pour preuve, notre modèle simple de cassure de symétries dans le modèle PPC a permis d’avoir des résultats compétitifs. Nos perspectives au niveau des méthodes complètes sont les suivantes : – aborder le problème d’optimisation (OP D) (Optimized Portfolio Design) avec la PLNE et la PPC, notamment en exploitant les solutions des recherches locales comme des bornes supérieures, – proposer un algorithme de cassure de symétrie plus adapté au contexte d’optimisation (OP D), – ré-exprimer notre problème PPC avec d’autres contraintes globales qui peuvent accélérer le processus de résolution. 6. Nous espérons avoir l’opportunité de combiner le principe des méthodes approchées et celui des méthodes complètes, afin de tirer profit des avantages des deux dans une approche hybride. 104

7. Étudier la possibilité d’exploiter les symétries du problème pour améliorer les performances des méthodes de recherche locale. 8. La modélisation de notre problème en puisant dans les concepts de la théorie des graphes est une piste à explorer.

105

106

Bibliographie Achterberg, T. (2005). Scip - a framework to integrate constraint and mixed integer programming. Rapport technique, ZIB, Takustr.7, 14195 Berlin. Achterberg, T. (2009). SCIP : solving constraint integer programs. Program. Comput., 1(1):1–41.

Math.

Achterberg, T., Berthold, T., Heinz, S., Koch, T. et Wolter, K. (2008a). Constraint integer programming : Techniques and applications. Rapport technique 08-43, ZIB, Takustr.7, 14195 Berlin. Achterberg, T., Berthold, T., Koch, T. et Wolter, K. (2008b). Constraint integer programming : A new approach to integrate cp and mip. In Perron, L. et Trick, M., éditeurs : Integration of AI and OR Techniques in Constraint Programming for Combinatorial Optimization Problems, 5th International Conference, CPAIOR 2008, volume 5015, pages 6–20. Aldous, D. et Pitman, J. (1994). Brownian bridge asymptotics for random mappings. Random Struct. Algorithms, 5(4):487–512. Ashwani, B. (2007). Collateral debt obligations. Rapport technique, GLOBAL STRATEGY AND INVESTMENT CONSULTING. Beldiceanu, N., Carlsson, M., Demassey, S. et Petit, T. (2007). Global constraint catalogue : Past, present and future. Constraints, 12(1):21–62. Benhamou, B. (1994). Study of symmetry in constraint satisfaction problems. In In Proceedings of CP-94, Lecture Notes in Computer Science, pages 246–254. Springer. Benhamou, B. et Saïdi, M. R. (2007a). Local symmetry breaking during search in csps. In Principles and Practice of Constraint Programming - CP 2007, 13th International Conference, CP 2007, Providence, RI, USA, September 23-27, 2007, Proceedings, pages 195–209. Benhamou, B. et Saïdi, M. R. (2007b). Local symmetry breaking during search in csps. In Principles and Practice of Constraint Programming - CP 2007, 13th International Conference, CP 2007, Providence, RI, USA, September 23-27, 2007, Proceedings, pages 195–209. Benhamou, B. et Saïdi, Mohamed, R. (2007). Elimination des symétries locales durant la résolution dans les CSPs. In Troisièmes Journées Francophones de Programmationpar Contraintes (JFPC07), JFPC07, INRIA, Domaine de Voluceau, Rocquencourt, Yvelines France. 107

Bhatt, R., Adams, A. et Clunie, J. (2005). Hidden risks in the cdo-squared market, working paper 05.03. Bisschop, J. (2006). Aimms Optimization Modeling. Paragon Decision Technology. Dimitriou, T. et Impagliazzo, R. (1996). Towards an analysis of local optimization algorithms. In Proceedings of the Twenty-Eighth Annual ACM Symposium on the Theory of Computing, Philadelphia, Pennsylvania, USA, May 22-24, 1996, pages 304–313. Dolan, E. D. et Moré, J. J. (2002). Benchmarking optimization software with performance profiles. Math. Program., 91(2):201–213. Duffie, D. et Singleton, K. J. (2003). Credit Risk : Pricing, Measurement, and Management. Princeton Series in Finance. Princeton University Press. Flener, P., Frisch, A., Hnich, B., Jefferson, C., Kiziltan, Z., Miguel, I., Pearson, J. et Walsh, T. (2003). Breaking symmetries in matrix models : A brief overview. In Proceedings of the Tenth Workshop on Automated Reasoning, pages 27–28. Flener, P., Frisch, A. M., Hnich, B., Kiziltan, Z., Miguel, I., Pearson, J. et Walsh, T. (2002). Breaking row and column symmetries in matrix models. In Hentenryck, P. V., éditeur : CP, volume 2470 de Lecture Notes in Computer Science, pages 462–476. Springer. Flener, P., Frisch, A. M., Hnich, B., K ?z ?ltan, Z., Miguel, I., Pearson, J. et Walsh, T. (2001). Symmetry in matrix models. In Proceedings of the CP’01 Workshop on Symmetry in Constraints, pages 41–48. Flener, P., Pearson, J. et Reyna, L. G. (2004). Financial portfolio optimisation. In CP, pages 227–241. LNCS 3258, Springer Berlin Heidelberg. Flener, P., Pearson, J., Reyna, L. G. et Sivertsson, O. (2007). Design of financial CDO squared transactions using constraint programming. Constraints, 12(2):179–205. Flener, P., Pearson, J., Sellmann, M., Hentenryck, P. V. et Ågren, M. (2009). Dynamic structural symmetry breaking for constraint satisfaction problems. Constraints, 14(4):506–538. Fonseca, G. H. G. et Santos, H. G. (2014). Variable neighborhood search based algorithms for high school timetabling. Computers & OR, 52:203–208. Fontaine, M. (2013). Apport de la déomposition arborescente pour les méthodes de type VNS. Thèse de doctorat, Université de Caen Basse-Normandie. École doctorale SIMEM, Université de Caen Basse-Normandie / Esplanade de la Paix / CS 14032 / 14032 CAEN cedex 5, France. Gent, I. P., Harvey, W., Kelsey, T. et Linton, S. (2003). Generic SBDD using computational group theory. In Principles and Practice of Constraint Programming - CP 2003, 9th International Conference, CP 2003, Kinsale, Ireland, September 29 - October 3, 2003, Proceedings, pages 333–347. 108

Gent, I. P. et Smith, B. (1999). Symmetry breaking during search in constraint programming. In Proceedings ECAI’2000, pages 599–603. Gilkes, K. et Drexler, M. (2003). Drill-down approach for synthetic cdo squared transactions. Rapport technique, Standard & Poor’s. RatingsDirect. Structured finance-New York. Ginsberg, M. L. (1993). Dynamic backtracking. J. Artif. Intell. Res. (JAIR), 1:25–46. Glover, F. et Laguna, M. (1997). Tabu Search. Kluwer Academic Publishers, Norwell, MA, USA. Godlewski, C., Hull, J., Merli, M., Hull, J., Godlewski, C. et Merli, M. (2010). Gestion des risques et institutions financières, chapitre 16, pages 345–363. Pearson. Guillaume, F., Jacobs, P. et Schoutens, W. (2008). Pricing and hedging of cdosquared tranches by using a one factor levy model. Rapport technique, Section of Statistics-Department of Mathematics-Katholike Universitit Leuven, Department of Mathematics, Celestijnenlaan 200 B, B-3001 Leuven, Belgium. Hager, S. (2008). Pricing Portfolio Credit Derivatives by Means of Evolutionary Algorithms, chapitre Collateralized Debt Obligations : Structure and Valuation, pages 7–39. Springer, Berlin Heidelberg. Hansen, P. et Mladenovic, N. (2009). Variable neighborhood search methods. In Encyclopedia of Optimization, Second Edition, pages 3975–3989. Henderson, D., Jacobson, S. H. et Johnson, A. W. (2003). The theory and practice of simulated annealing. In Glover, F. et Koshenberger, G. A., éditeurs : Handbook of Metaheuristics, volume 57, chapitre 8, pages 287–319. International Series in Operations Research and Management Science. Hentenryck, P. V., éditeur (2002). Principles and Practice of Constraint Programming - CP 2002, 8th International Conference, CP 2002, Ithaca, NY, USA, September 9-13, 2002, Proceedings, volume 2470 de Lecture Notes in Computer Science. Springer. Jarboui, B., Siarry, P. et Teghem, J. (2013). Métaheuristiques pour l’ordonnancement monocritère des ateliers de production. Productique. Recherche, technologie, applications. Hermès science publications. Kirkpatrick, S., Jr., C. D. G. et Vecchi, M. P. (1983a). Optimization by simulated annealing. Science, 220:671–680. Kirkpatrick, S., Jr., D. G. et Vecchi, M. P. (1983b). Optimization by simmulated annealing. Science, 220(4598):671–680. Kiziltan, Z. (2004). Symmetry Breaking Ordering Constraints. Thèse de doctorat, Uppsala University. Department of Information Science. Computer Science Division, Department of Information Science, Computer Science, Kyrkogardsg. 10, Box 513, Uppsala University, SE-751 20 Uppsala, Sweden. 109

Kurtz, D. et Pignard, T. B. (2004). Modélisation du risque de crédit. DEA de statistique et modèles aléatoires en économie et finance, Université Paris 7Université Paris 1, Le Centorial, 18 rue du 4 septembre, 75002 Paris. Laurière, J. (1978). A language and a program for stating and solving combinatorial problems. Artif. Intell., 10(1):29–127. Lawler, E. L. et Wood, D. E. (1966). Branch-and-bound methods : A survey. Operations Research, 14(4):699–719. Lebbah, F. Z. et Lebbah, Y. (2012). Une approche de résolution à population pour le problème du cdo carré. In Neuvième Colloque sur l’optimisation et les Systèmes d’information - du 12 au 15 mai, Tlemcen, Algérie, pages 128–155. Lebbah, F. Z. et Lebbah, Y. (2015a). A local search approach to solve a financial portfolio design problem. International Journal of Applied Metaheuristic Computing (IJAMC), 6(2):1–17. Lebbah, F. Z. et Lebbah, Y. (2015b). VNS approach for solving a financial portfolio design problem. Electronic Notes in Discrete Mathematics, 47:125–132. Lecoutre, C. (2013). Constraint Networks : Targeting Simplicity for Techniques and Algorithms. ISTE. Wiley. Marmion, M., Jourdan, L. et Dhaenens, C. (2013). Fitness landscape analysis and metaheuristics efficiency. J. Math. Model. Algorithms, 12(1):3–26. Marmion, M.-E. (2011). Recherche locale et optimisation combinatoire : De l’analyse structurelle d’un problème à la conception d’algorithmes efficaces. Thèse de doctorat, Université Lille 1 - École Doctorale Sciences Pour l’Ingénieur Université Lille Nord-de-France - Laboratoire d’Informatique Fondamentale de Lille (UMR CNRS 8022) - Centre de Recherche INRIA -Lille - Nord Europe. Marmion, M.-E., Dhaenens, C., Jourdan, L., Liefooghe, A. et Verel, S. (2012). Conception de recherche locale en présence de neutralité. In ROADEF 2012 : 13e congrès de la Société Française de Recherche Opérationnelle et d’Aide à la Décision, Angers, France. Marshall Hall, J. (1964). Applied combinatorial mathematics. chapitre Block designs, pages 369–405. Wiley, New York. Mears, C., de la Banda, M. G., Demoen, B. et Wallace, M. (2014). Lightweight dynamic symmetry breaking. Constraints, 19(3):195–242. Mladenovic, N. et Hansen, P. (1997). Variable neighborhood search. Computers & OR, 24(11):1097–1100. Neveu, B. (2005). Techniques de résolution des problèmes de satisfaction de contraintes. Thèse de doctorat, Université de Nice-Sophia Antipolis. Neveu, B. et Trombettoni, G. (2003). Incop : An open library for incomplete combinatorial optimization. In CP, pages 909–913. LNCS 2833, Springer Berlin Heidelberg. 110

Neveu, B. et Trombettoni, G. (2004). Hybridation de gww avec de la recherche locale. JEDAI, journal électronique d’intelligence artificielle : résolution pratique des problèmes NP-Complets, 3. Neveu, B., Trombettoni, G. et Glover, F. (2004). Id walk : A candidate list strategy with a simple diversification device. In CP, pages 423–437. LNCS 3258, Springer Berlin Heidelberg. Optra, O. (2006). Mieux appréhender les risques du portefeuille de négociation. Rapport technique, Direction de la Surveillance générale du système bancaireService des Affaires internationales. Banque de France-Revue de la stabilité financière. NÂ˚ 8. Papadimitriou, C. et Steiglitz, K. (1998). Combinatorial Optimization : Algorithms and Complexity. Dover Books on Computer Science Series. Dover Publications. Pedroso, J. P. (2001). Metaheuristics for combinatorial optimisation. Working Paper 9/01, Centro de Investigação Operacional da Universidade de Lisboa, Centro de Investigação Operacional, Faculdade de Ciências da Universidade de Lisboa, 1749-016 Lisboa, Portugal. Prins, C. (1994). Algorithmes de graphes avec programmes en PASCAL. Eyrolles. Puget, J.-F. (2006). An efficient way of breaking value symmetries. In AAAI, pages 117–122. Régin, J.-C. (2004). Modéisation et Contraintes Globales en Programmation par Contraintes. HABILITATION A DIRIGER DES RECHERCHES, Université de c Informatique. Nice-Sophia Antipolis. ECOLE DOCTORALE STIC. Spécialità Régin, J.-C. (2011). Global Constraints : a survey, in Hybrid Optimization, M. Milano and P. Van Hentenryck editors, pages 63–134. Springer. Reischuk, R. M., Schulte, C., Stuckey, P. J. et Tack, G. (2009). Maintaining state in propagation solvers. In Gent, I., éditeur : Fifteenth International Conference on Principles and Practice of Constraint Programming, volume 5732 de Lecture Notes in Computer Science, pages 692–706, Lisbon, Portugal. SpringerVerlag. Rossi, F., van Beek, P. et Walsh, T. (2006). Handbook of Constraint Programming. Foundations of Artificial Intelligence. Elsevier Science. Sahinidis, V. et Twarmalani, M. (2002). Convexification and Global Optimization in Continuous and Mixed-Integer Nonlinear Programming. Kluwer Academic Publishers Group. Schulte, C. (2002). Programming Constraint Services, volume 2302 de Lecture Notes in Artificial Intelligence. Springer-Verlag. Schulte, C. et Stuckey, P. J. (2008). Efficient constraint propagation engines. ACM Trans. Program. Lang. Syst., 31(1). 111

Schulte, C. et Tack, G. (2006). Views and iterators for generic constraint implementations. In Recent Advances in Constraints (2005), volume 3978 de Lecture Notes in Artificial Intelligence, pages 118–132. Springer-Verlag. Schulte, C., Tack, G. et Lagerkvist, M. Z. (2010). Modeling and programming with gecode. Sherali, H. et Adams, W. (1999). A Reformulation-Linearization Technique for Solving Discrete and Continuous Nonconvex Problems. Kluwer Academic Publishing. Tavakoli, J. M. (2008). Structured finance and collateralized debt obligations. J. Wiley & Sons. Walser, J. P. (1999). Integer Optimization by Local Search : Domain-independent Approach. Springer-Verlag, Berlin, Heidelberg.

A

Whetten, M. et Adelson, M. (2005). Cdos-squared demystified. Rapport technique, Nomura Fixed Income Research, Nomura Securities International, Inc. Two World Financial Center, New York, NY 10281-1198. Winston, W. L. (2004). Brooks/Cole, 4th édition.

Operations Research. Applications and Algorithms.

Wolpert, D. H. et Macready, W. G. (1997). No free lunch theorems for optimization. IEEE Transactions on Evolutionary Computation, 1(1):67–82. Wolsey, L. (1998). Integer Programming. A Wiley-Interscience publication. Wiley.

112

Résumé Ce mémoire décrit des approches algorithmiques de résolution du problème de conception des portefeuilles financiers provenant de l’ingénierie des finances. Il consiste à affecter aux portefeuilles des actifs qui doivent être variés, permettant ainsi un compromis entre la maximisation de la rentabilité et la minimisation du risque de perte. Ce problème est formalisable en terme d’un programme quadratique sur le domaine 0-1. Notre première contribution porte sur la proposition de méthodes approchées, à savoir les méthodes locales simples, les méthodes à voisinage variable et une méthode à population. A ce niveau, nous proposons deux fonctions de voisinage et une fonction coût qui tiennent compte de la sémantique particulière des contraintes du modèle. Nous proposons aussi un algorithme glouton qui calcule une solution initiale de bonne qualité. Notre mise en œuvre informatique a montré l’intérêt de nos approches sur des instances non triviales du problème. Notre deuxième contribution introduit des démarches complètes via la programmation linéaire en nombres entiers (PLNE) et la programmation par contraintes (PPC). Le modèle initial proposé par Flener et al. est posé dans un formalisme ensembliste. Justement, dans notre proposition d’un modèle en 0-1, les variables sont toutes regroupées dans une seule variable matricielle, où les différentes symétries du problème s’expriment d’une façon immédiate et simple. Nous proposons une reformulation linéaire exacte du modèle quadratique qui nous permet d’exploiter les solveurs PLNE. Nous avons mis au point un modèle à contraintes traitable avec un solveur PPC. L’intégration des symétries a permis d’accélérer significativement les performances du modèle PPC. Mots clés : Conception de portefeuilles financiers, VNS, Recuit Simulé, IDWalk, Programmation Par Contraintes, Cassure de symétries, Programmation Linéaire en Nombres Entiers. Abstract The aim of this thesis is to provide algorithms for solving the portfolio design problem coming from financial engineering. It is a critical problem in equitable management of clients portfolios. The problem can be formulated as a quadratic program on the 0-1 domain. In the first contribution of this work, we propose approximate approaches, namely simple local search methods, variable neighborhood search methods and a population based local search method. We introduce two neighborhood functions and an objective function which take into account the particular semantics of the constraints. We propose also a greedy algorithm which enables to get an optimized initial solution. We have implemented the proposed local search methods and showed that they are efficient on significantly large problems. The second contribution introduced exact approaches through integer linear programming and constraint programming models. We propose a matricial model where the different symmetries of the problem can be easily expressed. We have introduced an exact linearization of the problem, which enables to exploit linear programming solvers. We have also developed a constraint programming model. Breaking symmetries succeeded to boost significantly the performances of the CP model. Keywords : Financial Portfolio Design, VNS, Simulated Annealing, IDWalk, Constraint Programming, Symmetry Breaking, Integer Linear Programming. 113