Stratégie de recherche adaptative en programmation par contrainte

Université Paul Sabatier École Nationale de l Aviation Civile Master 2 Recherche Informatique et Télécommunication parcours Intelligence Artificielle Simon Marchal Stratégie de recherche adaptative en programmation par contrainte Application à l optimisation de séquence de décollages d avions Septembre 2010 Directeur de recherche : Nicolas Barnier Résumé : nous abordons dans ce rapport une stratégie de recherche adaptative en programmation par contraintes. Cette stratégie est orientée vers les conflits. Suite aux résultats encourageants obtenus, nous avons testé plusieurs modifications : schéma de branchement, stratégie de redémarrage, heuristique Last Conflict et hybridation avec de la recherche locale. Puis, après avoir testé nos stratégies sur un problème classique de Jobshop Scheduling, nous les avons appliquées à un problème d optimisation de séquence de décollages d avions sur un grand aéroport. Mots clés : - programmation par contraintes - gestion du trafic aérien - heuristiques adaptatives - Weighted Degree

Table des matières Introduction 1 1 Stratégie de recherche adaptative 3 1.1 Programmation par contraintes....................... 3 1.1.1 Problèmes de satisfaction de contraintes.............. 3 1.1.2 Algorithmes de résolution des CSP................. 5 1.1.3 Présentation de FaCiLe....................... 7 1.2 Heuristiques de choix de variables...................... 8 1.3 Heuristique de choix de variable Weighted Degree............. 10 1.3.1 Heuristique de choix de variable dirigée par les conflits...... 10 1.3.2 Exemple illustratif des Queens and Knights............ 11 1.3.3 Expérimentation complémentaire.................. 14 1.3.4 Discussion............................... 18 2 Quelques tentatives d améliorations 19 2.1 Schéma de branchement........................... 19 2.1.1 Description.............................. 19 2.1.2 Reprise de l exemple illustration des Queens and Knights.... 21 2.1.3 Expérimentation complémentaire.................. 21 2.1.4 Discussion............................... 22 2.2 Stratégie de redémarrage........................... 24 2.2.1 Présentation............................. 24 2.2.2 Étude expérimentale des paramètres................ 25 2.2.3 Discussion............................... 28 2.3 Heuristique Last Conflict.......................... 29 2.3.1 Présentation de l heuristique.................... 29 2.3.2 Algorithme.............................. 29 2.3.3 Reprise de l exemple illustration des Queens and Knights.... 30 2.3.4 Expérimentation complémentaire.................. 30 2.3.5 Discussion............................... 31 2.4 Une hybridation avec de la recherche locale................ 33 2.4.1 Introduction à la recherche locale.................. 33 2.4.2 Hybridation séquentielle....................... 36 i

2.4.3 Expérimentation........................... 41 2.4.4 Discussion............................... 42 3 Application à un problème de gestion du trafic aérien 44 3.1 Présentation de la gestion du trafic aérien................. 44 3.2 Problème de Job Shop Scheduling...................... 45 3.2.1 Présentation du problème...................... 45 3.2.2 Modélisation............................. 45 3.2.3 Stratégie de recherche........................ 46 3.2.4 Expérimentation........................... 48 3.2.5 Discussion............................... 48 3.3 Problème de séquencement d avion au décollage.............. 50 3.3.1 Présentation du problème...................... 50 3.3.2 Ressemblance avec le problème de Job Shop Scheduling..... 50 3.3.3 Modélisation............................. 51 3.3.4 Stratégie de recherche........................ 53 3.3.5 Expérimentation........................... 53 3.3.6 Discussion............................... 54 Conclusion 55 ii

Table des figures 1.1 Arbres de recherche en fonction de l ordre des variables......... 9 1.2 Exemple d une solution au problème des 8-reines.............. 11 1.3 Déplacement possible d un cavalier (à gauche) et cycle solution du problème des 6-cavaliers sur un échiquier de 64 cases (à droite)........... 12 1.4 Comparaison de l heuristique max et min dom ddeg sur différentes instances aléatoires................................ 17 1.5 Comparaison de l heuristique min dom dom et min ddeg sur différentes instances aléatoires............................... 18 2.1 Exemple d un arbre de branchement non binaire............. 20 2.2 Exemple d un arbre de branchement binaire................ 20 2.3 Comparaison de l heuristique min dom avec des branchements non binaires (en abscisse) et binaires (en ordonnée) sur différentes instances aléatoires................................... 23 2.4 La première ligne concerne la stratégie WTDI et la seconde concerne la stratégie RNDI. Les graphiques de droite sont les résultats expérimentaux en utilisant en plus une stratégie géométrique : on étudie les paramètres raison (q) et nombre de backtracks initial (C 0 ) avec un nombre de runs fixé à 50..................................... 27 2.5 Comparaison de l heuristique min dom ddeg (en abscisse) et cette même heuristique avec Last Conflict (en ordonnée) sur différentes instances aléatoires. 31 2.6 Comparaison de l heuristique min dom (en abscisse) et cette même heuristique avec Last Conflict (en ordonnée) sur différentes instances aléatoires. 32 2.7 Comparaison de l heuristique min dom avec une recherche locale Min- Conflict avec Liste Tabu........................... 38 2.8 Hybridation séquentielle des deux types de recherche............ 40 2.9 Résultats obtenus en fixant l tabu à 50.................... 42 2.10 Résultats obtenus en fixant nbiterations max à 2000............ 43 2.11 Résultats obtenus en fixant l tabu à 1,75................... 43 3.1 Illustration d un problème de Job Shop où 3 jobs doivent utiliser 3 machines différentes dans un ordre défini.................... 46 3.2 Une solution optimale au problème de Job Shop de la figure 3.1..... 47 3.3 Résultats expérimentaux........................... 48 iii

3.4 Une solution optimale d une instance énoncé par J.F. Muth et G.L. Thompson du problème de Job Shop........................ 49 3.5 Coût en fonction de l écart au temps CFMU................ 51 3.6 Séparation en fonction des types de mouvement et des catégories avions. 51 3.7 Résultats expérimentaux à différentes heures de la journée........ 54 3.8 Résultats obtenus en fixant l tabu à 50 (figure 2.9 page 42)......... 57 3.9 Résultats obtenus en fixant nbiterations max à 2000 (figure 2.10 page 43). 58 3.10 Résultats obtenus en fixant l tabu à 1,75 (figure 2.11 page 43)....... 59 3.11 Résultats obtenus pour la piste 27 à 8h00................. 61 3.12 Résultats obtenus pour la piste 27 à 13h00................. 62 iv

Liste des tableaux 1.1 Résultats expérimentaux des problèmes queensknights-n-k........ 13 1.2 Nombre totale de solutions au problème des n-queens en fonction du nombre de reines................................ 14 1.3 Nombre totale de backtracks pour prouver l inconsistance du problème des Knights en fonction de la taille de l échiquier pour 5 cavaliers.... 14 1.4 Résultats sur différentes instances du problème Radio Link Frequency Assignment................................... 15 1.5 Résultats sur différentes instances modifiée du problème Radio Link Frequency Assignment.............................. 16 1.6 Résultats sur différentes instances modifiée de l instance 11 du problème Radio Link Frequency Assignment...................... 16 2.1 Résultats expérimentaux des problèmes queensknights-n-k........ 21 2.2 Résultats expérimentaux complémentaires des problèmes queensknightsn-k....................................... 21 2.3 Résultats expérimentaux des problèmes queensknights-n-k........ 22 2.4 Résultats expérimentaux en secondes et en nombre de backtracks total (btks) avec différents paramètres pour la stratégie WTDI sur l instance SCEN11-F10.................................. 26 2.5 Résultats expérimentaux en secondes et en nombre de backtracks total (btks) avec différents paramètres pour la stratégie RNDI sur l instance SCEN11-F10.................................. 26 2.6 Résultats expérimentaux des problèmes queensknights-n-k........ 30 2.7 Résultats expérimentaux des instances du problème Radio Link Frequency Assignement................................. 33 2.8 Illustration de l initialisation gloutonne sur le problème des 4-Queens.. 36 2.9 Exécution de l algorithme Min-Conflict sur le problème des 4-Queens.. 37 2.10 Illustration du lissage d un minimum local par pondération des contraintes violées..................................... 39 v

Introduction Dans notre vie quotidienne, la notion de contrainte est naturellement très présente : il s agit aussi bien de ranger des objets de formes différentes dans une boîte, d établir des emplois du temps ou même de planifier le trafic aérien pour limiter les retards. Pour résoudre ces problèmes variés, il faut envisager souvent un très grand nombre de combinaisons avant d en trouver une qui satisfasse toutes les contraintes. Intégrée à un langage de programmation, la programmation par contraintes est un nouveau paradigme de programmation pour formuler et résoudre ces problèmes combinatoires. Constraint programming represents one of the closest approaches computer science has yet made to the Holy Grail of programming : the user states the problem, the computer solves it. 1 Eugene C. Freuder Dans un cas idéal, l utilisateur définit le problème à résoudre, le donne ensuite à l ordinateur, l ordinateur le résout et donne une solution. En raison de l aspect fortement combinatoire des problèmes à traiter, la puissance de calcul actuelle des ordinateurs ne suffit pas pour examiner toutes les combinaisons possibles en un temps acceptable. C est pourquoi, on essayera plutôt de définir le problème à résoudre pour qu il soit résolu efficacement, c est-à-dire avec un minimum d effort, puis on donnera à l ordinateur des pistes de résolution en introduisant des raisonnements et des heuristiques issues traditionnellement de l intelligence artificielle et qui permettent de réduire la combinatoire et de guider la recherche vers les bonnes combinaisons. Les domaines de l aéronautique et de la gestion du trafic aérien présentent de nombreux problèmes d optimisation combinatoire encore mal résolus, et utiliser la programmation par contraintes dans ce cadre présente de nombreux avantages : on bénéficie par exemple des avancés et des recherches issues d une communauté importante et de domaines d application variés. Contrairement à un algorithme spécifique, la programmation par contraintes permet également de disposer d un large éventail d algorithmes génériques de sorte qu une modification du problème initial (comme ajouter de nouvelles contraintes par exemple) ne nécessite pas forcément de modifier l algorithme de 1. La programmation par contraintes représente une des avancées qui se rapproche le plus du Saint Graal de la programmation que l informatique ait jamais réalisée : l utilisateur définit le problème, l ordinateur le résout. 1

résolution. C est pour ces raisons que le choix de la programmation par contraintes semble particulièrement intéressant. Bien évidemment, les problèmes de gestion du trafic aérien, comme beaucoup d autres problèmes, nécessitent que l on guide la recherche pour obtenir une solution en un temps acceptable. C est pourquoi, nous avons tenté dans notre premier chapitre une approche basée sur une stratégie de recherche adaptative introduite dans [3]. Dans un second chapitre, nous avons expérimenté diverses techniques permettant d améliorer la stratégie de recherche de solution décrite dans le premier chapitre. Enfin, dans un troisième chapitre, en se fondant sur des travaux réalisés sur les manières de formuler un problème de Jobshop Scheduling 2, nous appliquons les stratégies de recherche de solution présentées dans les deux premiers chapitres sur un problème de séquencement d avions au décollage d un aéroport. 2. Programmation des tâches à effectuer sur les machines d un atelier de production. 2

Chapitre 1 Stratégie de recherche adaptative 1.1 Programmation par contraintes 1.1.1 Problèmes de satisfaction de contraintes De nombreux problèmes peuvent être formulés comme des problèmes de satisfaction de contraintes (Constraint Satisfaction Problem, CSP) : un formalisme générique permet de les modéliser. On trouve par exemple de nombreux problèmes d ordonnancement, d allocation de ressource, emploi du temps, etc. L exemple 1 est un problème simple introductif aux problèmes de satisfaction de contraintes. Exemple 1. Exemple du cryptogramme SEND+MORE=MONEY. Le but est d associer un chiffre différent à chaque lettre tel que la somme soit vérifiée. S E N D + M O R E M O N E Y Une contrainte est une relation entre des inconnues ou variables d un problème qui restreint les combinaisons de valeurs qu elles peuvent prendre simultanément. De nombreuses contraintes arithmétiques comme les équations, inéquations, diséquations linéaires ou non peuvent être définies. De plus, des contraintes plus sophistiquées, dites symboliques, peuvent permettre par exemple de spécifier qu un ensemble d inconnues doivent avoir des valeurs distinctes (Alldiff), de spécifier le nombre d occurrences d une valeur dans un ensemble de variables (Cardinalité généralisée), etc. Ces contraintes arithmétiques et symboliques sont dotées de sémantiques particulières et sont exprimées en intention. Il est également possible d exprimer des contraintes sur des variables discrètes en donnant la liste exhaustive des tuples de valeurs autorisées ou interdites. Ces contraintes sont dites en extension. On notera vars (c) l ensemble des variables associé à une contrainte c. On dira qu une contrainte c lie ou implique une variable v si et seulement si v appartient à 3

vars(c). L arité d une contrainte c est le nombre de variables liées par celle-ci, c est-àdire vars(c). Dans la littérature, il est souvent fait référence à des contraintes binaires, c est-à-dire des contraintes qui lient deux variables. Les inconnues ou variables prennent leur valeurs dans un domaine défini initialement. Ces domaines peuvent représenter les booléens, les entiers, les rationnels, les intervalles de nombres flottants, les ensembles, les listes finies, etc. On remarquera que la complexité de la résolution d un problème dépend de son domaine : par exemple polynomiale pour les équations linéaires sur les réels et exponentielle lorsqu il s agit d entiers. On notera dom (v) le domaine de la variable v. Le degré d une variable v noté deg (v) est le nombre de contraintes liant celle-ci. Definition 1. Un réseau de contraintes (Constraint Network) est un couple ( V, C) où : V est un ensemble fini de n variables telles qu à chaque variable v est associé un domaine dom(v), indiquant l ensemble de valeurs autorisées pour v ; C est un ensemble fini de e contraintes telles qu à chaque contrainte c est associée une relation rel(c) indiquant l ensemble des tuples de valeurs autorisées pour les variables vars(c) H impliquées par la contrainte c. La définition 1 explicite la notion de réseau de contraintes qui permet de définir un problème de satisfaction de contraintes. On notera qu un tuple T sera dit autorisé par une contrainte c lorsque T rel (c). On peut illustrer la définition 1 sur l exemple 1 précédent. L ensemble des variables sera alors V = {S, E, N, D, M, O, R, Y }. Le domaine de chacune de ces variables sera : dom(x) = { [0; 9] si X {S, E, N, D, O, R, Y } [1; 9] si X = M Enfin, l ensemble des contraintes sera simplement le suivante : C = { 10 3 S + 10 2 E + 10 N + D +10 3 M + 10 2 O + 10 R + E = 10 4 M + 10 3 O + 10 2 N + 10 E + Y S E, S N, S D, S M, S O, S R, S Y, E...} Dans l exemple précédent, le but est de trouver simplement une solution qui satisfait les contraintes. Certains problèmes peuvent demander d autres types de résultats : trouver toutes les solutions qui satisfont les contraintes, trouver toutes les solutions qui satisfont les contraintes et qui minimisent ou maximisent un critère, prouver que le problème n a pas de solution, trouver la solution qui minimise le nombre de contraintes non satisfaites, etc. 4

Enfin, il sera utile dans la suite d utiliser des contraintes dites réifiée. La réification d une contrainte c introduit une nouvelle variable booléenne contrainte à être égale à 1 si c est satisfaite et à 0 si elle est violée. On peut alors ensuite utiliser ces nouvelles variables pour poser d autres contraintes. 1.1.2 Algorithmes de résolution des CSP Cette section présente essentiellement les algorithmes exacts de recherche arborescente de résolution des CSP. Les algorithmes approchés de recherche locale seront présentés dans la section 2.4.1. Les algorithmes de recherche constructive manipulent souvent des instanciations partielles en cherchant à les étendre pour obtenir une instanciation totale. Ces instanciations doivent satisfaire chaque contrainte du problème pour qu une solution puisse être obtenue (instanciation consistante). Une contrainte c est satisfaite si et seulement si l instanciation est autorisée par la contrainte c. Une solution d un CSP se caractérise donc simplement par une instanciation totale et consistante. On dira qu un CSP est consistant s il a au moins une solution et inconsistant s il n a aucune solution. On remarque que déterminer si un problème est consistant ou non est, en théorie de la complexité, un problème NP-Complet. Definition 2. Instanciation partielle Soit un réseau de contrainte ( V, C). Une instanciation partielle I est définie par un couple I = (V I, T ) tel que : V I = {v I1,..., v Ik } V est le sous-ensemble des variables sur lequel porte l instanciation ; T = (t I1,..., t Ik ) dom (v I1 ) dom (v Ik ) est un tuple de valeurs prises dans les domaines des variables à instancier. Definition 3. Instanciation totale Soit un réseau de contrainte ( V, C). Une instanciation totale I = (V I, T ) est une instanciation partielle pour laquelle V I = V. La méthode la plus simple pour chercher une solution d un CSP est d énumérer toutes les instanciations totales possibles et vérifier à chaque fois si elles sont consistantes ou non. Cette méthode naïve est appelée générer et tester. On remarque qu il faut éventuellement parcourir tout l espace de recherche avant de trouver une solution ou si l on souhaite obtenir un optimum ou l ensemble des solutions. La compléxité d un tel algorithme est alors exponentielle avec le nombre de variables. Afin de parcourir l espace de recherche systématiquement, on structure la recherche sous la forme d un arbre : chaque nœud correspond à une instanciation partielle ; chaque fils correspond à l extension de l instanciation partielle du nœud parent avec une nouvelle variable et une valeur différente des autres fils. On parcours cet arbre en profondeur 5

d abord. Ce type de recherche constitue la fondation des algorithmes systématiques. L algorithme générer et tester a pour défaut de ne vérifier la satisfaction des contraintes qu une fois l instanciation totale obtenue. Au lieu d attendre que toutes les variables soient instanciées pour tester la satisfaction des contraintes, on peut plutôt tester la satisfaction d une contraintes c dès que toutes ses variables sont instanciées. En détectant qu une instanciation partielle est inconsistante si elle viole une contrainte, on pourra élaguer le sous-arbre de recherche correspondant à ses extensions et réduire ainsi l espace de recherche. Il suffit alors d effectuer un retour arrière appelé aussi backtrack dans l arbre de recherche jusqu au nœud parent qui offre encore une branche non exploré : on revient alors à nouveau à une instantiation partielle consistante. Cependant, la complexité de ce type d algorithme reste exponentielle en pire cas. Cependant, cette stratégie de retour arrière présente des inconvénients et n exploite pas la structure des CSP. En effet, la technique de backtrack présenté remet en cause la dernière variable instanciée alors qu elle n est pas forcément la cause de l échec. Il existe des algorithmes de backtracks intelligents comme les techniques de backjumping proposé dans [6] par exemple qui essaye d effectuer un retour arrière directement vers une variable responsable de l échec. Ce genre de méthode fait partie des techniques rétrospectives (look-back). De plus, au lieu d attendre que toutes les variables liées à une contrainte soient instanciées pour la vérifier, on peut inférer des échecs bien avant grâce à des techniques prospectives (look-ahead) : on peut définir des propriétés de consistance locale (la consistance globale reviendrait à résoudre un CSP) qui permettent de simplifier le CSP en éliminant des valeurs de leur domaine pour éviter des échecs a priori grâce à des algorithmes de complexité polynomiale. Ces techniques de consistance ont fait l objet de très nombreuses recherches, notamment sur les algorithmes d arc-consistance. Il existe également une autre forme de consistance, la consistance aux bornes, où on élimine les valeurs uniquement aux bornes du domaines : ce type d algorithme est plus rapide puisqu on ne considère que les bornes du domaine. Cette phase d inférence a lieu notamment à chaque nœud de l arbre de recherche : après avoir instancié une variable, on essaye de déduire un certain nombre de connaissances. Cette phase est appelé propagation de contraintes. Ainsi, le principe générale de résolution de CSP peut alors se résumer en 2 phases : propagation de contraintes et élagage, puis exploration. On notera que ces algorithmes de recherche ont une caractéristique importante : la complétude 1. Reste encore un point important : l ordre d instanciation des variables. En effet, cet ordre est primordial et deux ordres d instanciation différents peuvent avoir des efficacités très différentes. C est le sujet abordé dans les sections suivantes : après une courte introduction à FaCiLe, la librairie de programmation par contraintes utilisée pour nos implémentation, on parlera des heuristiques de choix de variables et notamment de celles dirigées vers les conflits. 1. Un algorithme est complet s il garantit de trouver la solution du problème en un temps fini. 6

1.1.3 Présentation de FaCiLe Le concept de programmation par contraintes est à l origine issu d une volonté d extension des systèmes Prolog. Intégré à un langage de programmation, la programmation par contrainte offre un langage de modélisation d un CSP et un langage de paramétrage de la recherche. Elle permet également de séparer le modèle des procédures de recherche de solution : ainsi, une modification du modèle n entraine pas forcement une modification des algorithmes de recherche de solution. FaCiLe, pour Functional Constraints Library est une librairie de programmation par contraintes développée par N.Barnier et P. Brisset. Cette librairie est simple, concise et Open Source 2. Elle est complètement écrite en Objective Caml 3. La librairie assure de nombreuses fonctionnalités. Par exemple, des modules permettent de représenter les domaines et les variables avec gestion d une traînée (trailing) utile pour les backtracks. Des modules permettent également de représenter des contraintes arithmétiques, globales (Alldiff, Cardinalité généralisée, Tri, etc.) ainsi que des contraintes utilisateurs. La librairie est également dotée d un mécanisme d événements qui permet d attacher un objets réactif à un événement, c est-à-dire une contrainte. Elle possède également un langage des buts expressif : FaCiLe contrôle la recherche de solution avec des buts explorés traditionnellement en profondeur d abord. Enfin, d autres mécanismes génériques sont proposés par la librairie comme les références backtrackables qui permettent de faire vivre des structures de données avec le backtrack ou les invariants qui permettent de maintenir des structures de données liées fonctionnellement entre elles. Plus de détails sur FaCiLe sont donnés dans [2]. 2. on peut la télécharger sur www.recherche.enac.fr/opti/facile 3. Le site officiel : caml.inria.fr, un langage de programmation fonctionnel, également Open Source et developpée à l INRIA. 7

1.2 Heuristiques de choix de variables De nombreux efforts ont été effectués sur l ordre dans lequel on assigne les variables au cours de la recherche. En effet, selon les choix que l on effectue, on peut obtenir des performances très différentes. Cette section présente les heuristiques de choix de variable. On distingue généralement trois catégories permettant de classer les heuristiques de choix de variables : 1. Les heuristiques statiques : l ordre de choix de variables est établi à partir de la structure initiale du problème. Le même ordre est conservé tout au long de la recherche. Les heuristiques les plus répandues sont généralement : lexico : l ordre des variables est l ordre lexicographique, c est-à-dire la variable V i sera choisie avant la variable V j si i < j ; max deg : les variables sont choisies suivant l ordre décroissant de leur degré (c est-à-dire le nombre de contraintes auxquelles elles sont liées) initial ; max ddeg : les variables sont choisies suivant l ordre décroissant de leur degré courant. Cette heuristique est appelé degré dynamique mais un tel ordre peut être calculé initialement, c est pourquoi il s agit d une heuristique statique. 2. Les heuristiques dynamiques : l ordre de choix de variables exploite l état courant du problème. C est par exemple le cas de l heuristique min dom qui consiste à ordonner les variables suivant l ordre croissant de la taille de leur domaine. Il existe également des heuristiques combinant taille du domaine et degré initial noté min dom deg dom et sa variante utilisant le degré courant noté min ddeg. Ces heuristiques sont intéressantes car elles peuvent améliorer les performances de recherche : elles sont notamment beaucoup plus efficace que les heuristiques statiques car elles exploitent les informations obtenues durant la résolution du problème. 3. Les heuristiques adaptatives : l ordre de choix de variables exploite l état courant du problème mais aussi des informations sur les états passés collectées pendant la recherche. Les heuristiques que l on présentera par la suite font partie de cette catégorie (les heuristiques de choix de variables dirigée vers les conflits et l heuristique Last Conflict). Il est très important de bien choisir l ordre dans lequel un algorithme de recherche va choisir les variables à assigner. Pour une même instance, des heuristiques de choix de variables différentes peuvent avoir des efficacités très variées. Afin de justifier l utilisation de l heuristique min dom par exemple, on trouve dans [12] une justification basée sur le principe fail-first suivant : To succeed, try first where you are most likely to fail. 4 Pour réduire l espace de recherche, il est plus avantageux de couper l arbre de recherche le plus proche possible de la racine plutôt que proche des feuilles car on réduit davantage l espace de recherche lorsqu on est près de la racine. Ce principe sera également 4. Pour réussir, essayons d abord là où l on est le plus susceptible d échouer 8

à la base de la justification des heuristiques présentés dans les sections suivantes. Pour bien comprendre l importance de l ordre d instanciation des variables, considérons l exemple suivant sur trois variables A, B et C. Le domaine de A contient 3 éléments et ceux de B et C en contiennent chacun 2. On suppose qu il faut l intégralité de l espace de recherche (pour prouver une inconsistance par exemple) et que les propagations ne réduisent pas les domaines des variables. La figure 1.1 montre les arbres de recherche que l on obtiendrait en supposant que l on considère l ordre d instanciation des variables lexico (A, B puis C) ou min dom (B, C puis A). On s aperçoit alors que l ordre lexico explorera plus de noeuds que min dom pour prouver la même inconsistance. Réduire le nombre de noeuds implique également réduire le nombre de propagation de contraintes, phase qui nécessite beaucoup de temps de calcul. C est pourquoi l heuristique de choix de variable est si importante. lexico min dom (22 noeuds) (19 noeuds) Figure 1.1 Arbres de recherche en fonction de l ordre des variables On notera pour finir qu il est également possible qu une heuristique ne permette pas de départager un sous-ensemble de variables appelé aussi Tie (par exemple si elles ont la même taille de domaine pour l heuristique min dom) : dans ce cas, on choisira implicitement ensuite l ordre lexicographique. 9

1.3 Heuristique de choix de variable Weighted Degree Afin d introduire l heuristique Weighted Degree, nous avons suivi la démarche présenté dans [3]. On commencera par présenter l heuristique que l on testera sur un premier exemple illustratif afin de comprendre comment agit cette heuristique. Puis, nous testerons également sur d autres problèmes que l on expliquera dans cette partie. 1.3.1 Heuristique de choix de variable dirigée par les conflits Les heuristiques de choix de variable classiques n exploitent au mieux que l état courant de la recherche (heuristiques dynamiques). Aucune information sur les états passés n est exploitée. Dans [3], on propose alors de pondérer les contraintes en introduisant un compteur noté weight associé à chaque contrainte qui comptabilisera le nombre de fois que la propagation de la contrainte a mené à un échec (conflit). L intérêt principal des heuristiques dirigées par les conflits est d exploiter des informations sur les états passés afin d isoler les parties difficiles ou inconsistantes d un problème. Pour toute contrainte C i, on notera weight (C i ) le compteur précédemment introduit. De plus, on notera également futv ars (C i ) l ensemble des variables non assignées (appelée aussi variables futures) liées à C i. On définit alors une nouvelle heuristique de choix de variables notée max appelée Weighted Degree (degré pondéré). Sa fonction d évaluation des variables α pour la variable V i est donnée par : α (V i ) = weight (C j ) V i vars(c j ) futv ars(c j ) >1 Le degré pondéré d une variable V i est alors la somme des poids de toutes les contraintes impliquant V i et au moins une autre variable non affectée. En remarquant que la propagation des contraintes des parties les plus difficiles voire inconsistante va échouer plus souvent, le compteur weight de ces contraintes va augmenter au cours de la recherche et le degré pondéré des variables liées à ces contraintes va également augmenter. Ce qui implique qu en choisissant en premier les variables de degré pondéré le plus élevé, la recherche de solution sera orientée vers ces parties difficiles ou inconsistantes. On remonte alors vers la racine de l arbre de recherche les variables qui risquent d engendrer un échec rapidement. On suit alors le principe fail-first expliqué précédemment. De plus, on fixera initialement les compteurs weight à 1. Ainsi, la fonction d évaluation d une variable donnée ne prendra en compte initialement que les contraintes impliquant cette variable et au moins une autre variable encore non assignée. max est alors équivalent à max ddeg lorsque tous les compteurs weight sont fixés à 1. On bénéficie alors du degré des variables au début de la recherche de solution. Enfin, on notera min dom l heuristique qui sélectionne en premier les variables de plus petit rapport entre la taille courante du domaine de la variable et son degré pondéré courant. Initialement, lorsque tous les poids sont fixés à 1, on a alors une heuristique 10

équivalente à min dom ddeg. Il peut arriver que l ordre généré par ces heuristiques fasse apparaître des variables équivalentes, c est-à-dire dont la fonction d évaluation est égale. Dans ce cas, si rien est mentionné, on choisira alors implicitement lexico pour départager ces variables. On appellera heuristiques de choix de variables dirigées par les conflits les deux heuristiques max ddeg et min dom présentées précédemment. 1.3.2 Exemple illustratif des Queens and Knights Le but de cet exemple est d illustrer le phénomène de thrashing et de montrer l intérêt des heuristiques de choix de variable dirigées par les conflits. Le thrashing est le fait d explorer plusieurs fois la même inconsistance. Description du problème Ce problème des Queens and Knights est né de la fusion de deux problèmes. Il possède un sous-problème inconsistant qui permettra d illustrer l intérêt des heuristiques de choix de variables dirigées par les conflits. Le premier problème est le problème classique des n-queens. On dispose d un échiquier de taille n n sur lequel on cherche à placer n reines de telle sorte qu aucune reine ne soit attaquée par une autre. Les reines attaquent soit en ligne droite (verticale et horizontale), soit en diagonale. Un exemple de solution est donné figure 1.2. Figure 1.2 Exemple d une solution au problème des 8-reines. Le second problème est celui des Knights illustré par la figure 1.3. On dispose d un échiquier de taille n n sur le quel on souhaite placer k cavaliers de telle sorte que les cavaliers forment un cycle. Un cycle est constitué des k cavaliers et chacun d entre eux est lié au suivant (modulo k) par un saut, c est-à-dire un déplacement d une case dans un sens puis de deux cases dans l autre ou d un déplacement de deux cases dans un 11

sens puis d une dans l autre sens. Pour obtenir un cycle, on peut noter par exemple les variables représentants les cavaliers X i, i [1; k]. Chaque variable X i a pour domaine [ 0; n 2 [, chaque valeur représentant une case différente de l échiquier. Puis, pour tout i [1; k] et j = i + 1 mod k, on peut poser les contraintes : ( ) ( ) v i v j n = 1 v i v j mod n = 2 v i v j n = 2 v i v j mod n = 1 La figure 1.3 rappelle les déplacements d un cavalier et présente une solution à un problème des cavaliers pour k = 6. On remarque enfin que ce problème est inconsistant pour les valeurs de k impaires. Figure 1.3 Déplacement possible d un cavalier (à gauche) et cycle solution du problème des 6-cavaliers sur un échiquier de 64 cases (à droite). En fusionnant de manière indépendante ces deux problèmes, celui des n-queens et celui des Knights, et en choisissant un nombre impair de cavaliers, on obtient un problème contenant un sous problème inconsistant (celui des cavaliers). Afin de pouvoir vérifier et comparer nos résultats, nous avons utilisé la modélisation (représentée au format XCSP décrite en annexe) disponible sur le site de C. Lecoutre 5. Le problème des n-queens est représenté de manière classique : chaque reine est placée sur une ligne et on lui associe une variable dont le domaine comprend n valeurs qui représentent sa colonne. Des contraintes binaires garantissent que chaque reine n est pas attaquée par une autre. Le problème des cavaliers est représenté par k variables dont le domaine comprend n 2 valeurs qui représentent la position de chaque cavalier dans l échiquier. Des contraintes binaires représentent le fait que chaque cavalier occupe une case différente et qu ils forment un cycle. 5. http://www.cril.univ-artois.fr/~lecoutre 12

Expérimentation et Comparaison Nous avons implémenté les heuristiques dirigées par les conflits dans FaCiLe puis nous les avons testées sur le problème des Queens and Knights décrit précédemment. On les a également testées sur une variante de ce problème qui consiste à interdire en plus qu une reine et un cavalier occupe la même case de l échiquier. Nous avons repris la démarche de [3] afin de pouvoir vérifier les résultats obtenus. instance heuristique classique variante backtracks temps (s) backtracks temps (s) queensknights-8-5 min dom 6049 4.235 5305 4.496 min dom ddeg 6049 4.247 5305 4.477 max 717 0.499 696 0.718 min dom 726 0.499 1091 1.004 queensknights-10-5 min dom 75181 86.198 67893 96.903 min dom ddeg 75181 87.281 67893 96.223 max 2309 2.735 2250 3.934 min dom 2863 3.349 2901 4.773 queensknights-12-5 min dom > 300 > 300 min dom ddeg > 300 > 300 max 4918 8.977 4830 13.074 min dom 6141 10.898 6474 16.313 Table 1.1 Résultats expérimentaux des problèmes queensknights-n-k. Analyse La force de l approche des heuristiques dirigées par les conflits est d identifier les parties les plus difficiles à satisfaire. Sur l exemple, on constate que les heuristiques max et min dom vont prouver l insatisfiabilité des problèmes rapidement. Les heuristiques classiques min dom et min dom ddeg ont un comportement différent : en effet, en comparant les résultats obtenues avec ceux des tableaux 1.2 et 1.3 qui présentent le nombre de solutions au problème des n-queens et le nombre de branchements nécessaires à prouver l inconsistance du problème des Knights, on s aperçoit que ces heuristiques sont fortement soumis au thrashing. Si on multiplie simplement le nombre de solution du problème des n-queens par le nombre de backtracks nécessaire pour prouver l inconsistance du problème des Knights, on obtient sensiblement le même résultat que ceux du tableau 1.1. L algorithme de recherche de solution redécouvre plusieurs fois la même inconsistance. Par exemple, en effectuant 724 100, on obtient 72400 ce qui est proche de 75181 (la différence s explique par le nombre de backtracks nécessaire pour trouver toutes les solutions des n-queens). Ainsi, les heuristiques dirigées par les conflits ont 13

l avantage d éviter le thrashing en pondérant les contraintes les plus difficiles à satisfaire, c est-à-dire celles liées aux cavaliers. n (nombre de reines) 8 10 12 nombre de solution 92 724 14200 Table 1.2 Nombre totale de solutions au problème des n-queens en fonction du nombre de reines. n (taille de l échiquier) 8 10 12 nombre de backtracks 64 100 144 Table 1.3 Nombre totale de backtracks pour prouver l inconsistance du problème des Knights en fonction de la taille de l échiquier pour 5 cavaliers. 1.3.3 Expérimentation complémentaire On a également testé les heuristiques présentées précédemment sur d autres problèmes : le problème d allocation de fréquences de liaison radio et sur des instances de problèmes aléatoires. Chaque instance sera testée au minimum 5 fois ; les résultats expérimentaux présentent les valeurs moyennes obtenues. Problème d allocation de fréquences de liaison radio(radio Link Frequency Assignment Problems) Le problème Radio Link Frequency Assignment présenté dans [4] a été proposé par le Centre d Électronique de l Armement. Il est issu d un problème réel avec des données simplifiées. On dispose de plusieurs sites qui doivent garder le contact radio. Le problème consiste en l allocation de fréquence à chaque lien radio entre deux sites en évitant les interférences. Chaque lien radio est représenté par une variable dont le domaine est l ensemble des fréquences disponibles pour ce lien. Puis, pour deux lien radio F i et F j proches (c est-à-dire susceptibles d interférer), on dispose d une constante k i,j qui représente l écart minimum entre les deux fréquences pour qu il n y ait pas d interférence (cette constante a été calculée à partir de modèle sur les ondes électromagnétiques et souvent surestimée pour garantir l absence d interférence). On obtient alors la contrainte : F i F j > k i,j De plus, pour chaque paire de site A et B, deux fréquences doivent être assignées : une pour la communication de A vers B et l autre pour celle de B vers A. Une contrainte liée à la technologie employée est ajoutée : l écart entre la fréquences du lien entre A à B et celle du lien entre B et A doit être exactement de 238. On a alors une deuxième contrainte du type : 14

F A B F B A = 238 On s intéressera simplement à satisfaire les instances (il est également possible de minimiser le nombre de fréquences utilisées, minimiser le maximum des fréquences, etc.). On testera sur les instances classiques satisfiables 1, 2, 3, 4, 5 et 11 (les instances 6, 7, 8, 9 et 10 sont sur-contraintes). Les instances 1, 2 et 3 sont des sous-problèmes du problème original. Les instances 4 et 5 sont plus contraintes. L instance 11 est la plus grande composante connexe 6 du graphe du problème original. Cette instance implique 680 variables et 4103 contraintes. On utilisera également là encore la modélisation au format XCSP disponible sur le site de C. Lecoutre. Le tableau 1.4 présente les résultats obtenus. On observe que s il ne se passe rien de vraiment significatif sur les premières instances, l instance 11 montre des différences : l heuristique min dom ddeg semble avoir un peu plus de difficulté à élaborer une solution. Comme on l espérait, l heuristique max semble découvrir peu à peu les parties les plus difficiles du problème. Enfin, min dom montre l intérêt d orienter initialement la recherche avec la taille du domaine. On peut noter qu initialement les heuristiques dirigées par les conflits ne sont pas ou peu informées. instance min dom ddeg max min dom temps (s) backtracks temps (s) backtracks temps (s) backtracks SCEN1 0.606 55 0.605 54 0.626 55 SCEN2 0.070 3 0.067 1 0.068 3 SCEN3 0.228 13 0.218 13 0.219 13 SCEN4 0.294 48 0.316 89 0.289 48 SCEN5 0.134 8 0.128 7 0.130 8 SCEN11 294.869 96251 6.095 1474 2.418 585 Table 1.4 Résultats sur différentes instances du problème Radio Link Frequency Assignment. Afin de tester la robustesse de ces heuristiques, nous les avons également testé sur des instances (toujours disponibles au format XCSP sur le site de C. Lecoutre) du problème Radio Link Frequency Assignment modifiées introduite par C. Bessière, A. Chmeiss et L. Saïs 7. Ces instances sont produites en supprimant des contraintes (noté W ) ou certaines fréquences (noté F ). Par exemple, l instance RLFAP-SCEN9-W1- F3 correspond à l instance RLFAP-SCEN9 à laquelle on a retiré les contraintes de poids supérieur à 1 et les 3 plus hautes fréquences. On testera également sur les instances 6, 7, 8, 9 et 10 modifié dont on cherche à prouver l inconsistance. Le tableau 1.5 présente 6. Un graphe connexe est un graphe dans lequel chaque paire de sommets est reliée par une chaîne. Dans un graphe, une composante connexe est un sous-graphe maximal connexe 7. Ces instances modifiées ont servi à prouver la robustesse de leur approche dans l article Neighborhood-based variable ordering heuristics for the constraint satisfaction problem 15

les résultats obtenus. Ces résultats confirment l utilité de l approche des heuristiques dirigée par les conflits par rapport à une heuristique classique tel que min dom ddeg. instance min dom ddeg max min dom temps (s) backtracks temps (s) backtracks temps (s) backtracks SCEN1-F8 > 300-6.203 3691 0.874 212 SCEN1-F9 > 300-77.710 27964 7.521 2976 SCEN2-F24 0.240 39 0.289 201 0.190 32 SCEN2-F25 > 300-26.137 5801 87.652 22457 SCEN3-F10 > 300-4.092 2128 0.814 236 SCEN3-F11 > 300-20.538 10357 29.243 13730 SCEN6-W1-F2 > 300-0.114 621 1.966 10805 SCEN6-W1 0.020 32 0.019 43 0.019 32 SCEN6-W2 0.050 20 0.048 20 0.048 20 SCEN7-W1-F4 0.049 91 0.051 108 0.047 82 SCEN7-W1-F5 > 300-0.970 2596 4.359 11347 SCEN9-W1-F3 > 300-0.075 292 1.343 6506 SCEN10-W1-F3 > 300-0.076 292 1.346 6506 Table 1.5 Résultats sur différentes instances modifiée du problème Radio Link Frequency Assignment. On a également effectué des tests complémentaires sur des instances modifiées de l instance 11, l instance la plus intéressante du tableau 1.4. De même que dans le paragraphe précédent, ces instances ont été produites en retirant uniquement des fréquences (noté F ). Par exemple RLFAP-SCEN11-F10 correpond à l instance 11 à laquelle on a retiré les 10 plus hautes fréquences. Le tableau 1.6 présente les résultats obtenus. On remarque que l heuristique min dom ddeg n arrive toujours pas à trouver de solution (en moins de 300 secondes) alors que les heuristiques max et min dom L heuristique min dom trouvent une solution. semble plus stable (le temps de calcul et le nombre de backtracks varient moins) sur ces 3 dernières instances, conséquence de la prise en compte de la taille du domaine (donc du nombre de fréquences disponibles) pour chaque variable, guidant ainsi l heuristique lorsqu elle manque d information. instance min dom ddeg max min dom temps (s) backtracks temps (s) backtracks temps (s) backtracks SCEN11-F1 à F9 > 300 - > 300 - > 300 - SCEN11-F10 > 300-160.396 47751 27.999 8597 SCEN11-F11 > 300-14.327 5401 23.214 8227 SCEN11-F12 > 300-14.479 5502 23.420 8220 Table 1.6 Résultats sur différentes instances modifiée de l instance 11 du problème Radio Link Frequency Assignment. 16

Instance de problèmes aléatoires Le modèle d instance de problèmes aléatoires utilisée ici est celui décrit dans [20]. L avantage de la technique de génération de [20] est quelle permet de générer des instances aléatoires difficiles simplement. En faisant varié différent paramètre comme le nombre de variables, la taille des domaines, le nombre de contraintes ou la proportion de tuples interdit pour chaque contraintes, il est possible de générer une multitude d instance différente. L avantage est que l on peut créer des problèmes aussi difficiles que l on veut en fonction de ce qu on souhaite expérimenter. Il arrive parfois que certaines instances soient insatisfiable : on peut alors les forcer à être satisfiable. Pour nos expérience, nous avons utilisés plusieurs instances difficile disponible au format XCSP sur le site de C. Lecoutre. Les figures 1.4 et 1.5 présentent les résultats obtenues. Chaque point représente une instance aléatoire particulière. En abscisse, on trouve les temps de calcul (puis les nombres de backtracks) pour l heuristique min dom ddeg et en ordonnée, ceux pour l heuristique max sur la figure 1.4 et ceux pour l heuristique min dom sur la figure 1.5. On remarque que l heuristique max a plus de difficulté à trouver une solution que min dom dom ddeg alors que min en revanche a une efficacité presque similaire à celle de min dom ddeg. Cette exemple montre l intérêt d orienter la recherche initialement avec la taille courante du domaine. sur différentes ins- Figure 1.4 Comparaison de l heuristique max et min dom ddeg tances aléatoires. 17

Figure 1.5 Comparaison de l heuristique min dom aléatoires dom et min ddeg sur différentes instances 1.3.4 Discussion Les résultats obtenus sur le problème des Queens and Knights montrent bien l intérêt de l approche des heuristiques dirigées par les conflits. Elles permettent de découvrir par elles-mêmes les parties inconsistantes d un problème. Ce point fort a également été exploité sur le problème de Radio Link Frequency Assignment où elles identifient les parties les plus difficiles comme le montre les résultats obtenus. Cependant, sur des instances de problèmes aléatoires, on remarque que ces heuristiques adaptative manque d information initialement : l heuristique max se montre peu efficace. L idée d orienter la recherche en combinant le degré pondéré des contraintes avec la taille du domaine donne de meilleur résultats : la taille du domaine est utile pour guider l heuristique au début la recherche jusqu à ce que le degré pondéré deviennent prépondérant. Cette dernière remarque montre qu il est possible d apporter des améliorations pour guider davantage la recherche. Les résultats obtenues sur les instances du problèmes de Radio Link Frequency Assignment montrent que cette heuristique présente un intérêt sur des problèmes réels. On peut alors supposer que lorsqu on ne dispose pas d une expertise suffisante pour développer une heuristique spécifique pour un problème réel donné, utiliser une heuristique de ce type semble donner des résultats acceptables. 18

Chapitre 2 Quelques tentatives d améliorations L heuristique adaptative Weighted Degree collecte des informations à partir des échecs apparaissant lorsqu une solution partielle ne peut être étendue. Le principe failfirst présenté section 1.2 souligne l importance de bien choisir les premières variables à instancier. Cependant, on remarque que l heuristique Weighted Degree effectue les choix les plus importants (le choix des premières variables) avec très peu d informations alors que des choix moins important (le choix des variables en bas de l arbre de recherche) bénéficient de plus d informations. Les sections qui suivent proposent plusieurs améliorations afin que les premiers choix ne pénalisent pas la recherche de solution. 2.1 Schéma de branchement Une première idée pour tenter d améliorer l efficacité de l heuristique Weighted Degree est d utilisé un schéma de branchement binaire. 2.1.1 Description Un schéma de branchement peut être vu comme la manière dont on va faire progresser la solution partielle obtenue : son rôle est de séparer le problème à traiter en sous-problèmes complémentaires plus simples en assignant ou interdisant par exemple une valeur à une variable encore non instanciée. On peut considérer deux types principaux de branchement : branchement binaire (appelé aussi 2-way) ou non binaire (appelé aussi d-way, où d représente le nombre d éléments du domaine de la variable). Ces deux types de schéma ne sont pas équivalents. Il a été démontré dans [13] que le branchement binaire était plus puissant que le branchement non binaire. 19

X i = u 0 X i = u 1 X i = u i X i = u n...... Figure 2.1 Exemple d un arbre de branchement non binaire La figure 2.1 présente un branchement non binaire (c est le type de branchement utilisé dans la partie précédente). À chaque point de choix, on choisi une variable X encore non assignée. En notant d la taille de son domaine, on va brancher d fois sur chacune des valeurs de X. X i = u X i u X i+1 = v. X i+1 v. Figure 2.2 Exemple d un arbre de branchement binaire Pour le schéma de branchement binaire, à chaque point de choix, on choisit un couple (X, v) où X est une variable encore non assignée et v une valeur appartenant au domaine courant de X. Dans un premier cas, on considère l assignation X = v (décision positive). Dans un second cas, en conséquence de l exploration effectuée avec la première décision, on considère alors sa réfutation, c est-à-dire : X v (décision négative). La figure 2.2 illustre un tel branchement. Les définitions 4 et 5 formalisent la notion de décision. Definition 4. Soient P = (H, C) un réseau de contraint et un couple (X, v) tel que X H et v dom(x). L assignation X = v est appelée décision positive tandis que la réfutation X v est appelée décision négative. Definition 5. Soient P un réseau de contrainte et un ensemble de décisions. P est le réseau de contrainte obtenu à partir de P tel que pour toute décision positive (X = v), dom (X) est restreint à la valeur {v} et pour toute décision négative (X v), v est supprimé de dom (X). 20

2.1.2 Reprise de l exemple illustration des Queens and Knights On s intéresse essentiellement ici à mettre en évidence l impact du type de branchement sur les heuristiques dirigées par les conflits. On reprend l exemple de la section 1.3.2 et sa variante. Le tableau 2.3 présentent les résultats obtenus en fonction du type de branchement. On constate des résultats clairement meilleurs en terme de nombre de backtracks et de temps de calcul lorsqu on utilise un arbre de branchement binaire. instance heuristique classique variante backtracks temps (s) backtracks temps (s) qk-8-5 max d-way 717 0.499 696 0.718 2-way 184 0.122 251 0.264 min dom d-way 726 0.499 1091 1.004 2-way 339 0.238 596 0.560 qk-10-5 max d-way 2309 2.735 2250 3.934 2-way 184 0.126 506 0.907 min dom d-way 2863 3.349 2901 4.773 2-way 1555 1.831 1171 1.813 qk-12-5 max d-way 4918 8.977 4830 13.074 2-way 184 0.124 911 2.575 min dom d-way 6141 10.898 6474 16.313 2-way 1544 2.684 3503 8.313 Table 2.1 Résultats expérimentaux des problèmes queensknights-n-k. 2.1.3 Expérimentation complémentaire Le tableau 2.2 présentent des résultats complémentaires au problème des Queens and Knights obtenus grâce à un branchement binaire. instance heuristique classique variante backtracks temps (s) backtracks temps (s) queensknights-15-5 max 184 0.124 2300 10.728 min dom 3249 9.680 5147 20.406 queensknights-20-5 max 184 0.120 11325 135.812 min dom 7316 42.054 13167 99.749 queensknights-25-5 max 184 0.126 10413 158.135 min dom 23400 215.004 22705 279.701 Table 2.2 Résultats expérimentaux complémentaires des problèmes queensknightsn-k. 21

La tableau 2.3 présente les résultats obtenus sur le problème Radio Link Frequency Assignment pour les deux types de branchements binaires (2-way) et non binaires (dway). instance branchement max min dom backtracks temps (s) backtracks temps (s) SCEN1 d-way 54 0.605 55 0.626 2-way 54 0.672 57 0.831 SCEN2 d-way 1 0.067 3 0.068 2-way 1 0.067 2 0.076 SCEN3 d-way 13 0.218 13 0.219 2-way 13 0.224 11 0.254 SCEN4 d-way 89 0.316 48 0.289 2-way 73 0.367 52 0.330 SCEN5 d-way 7 0.128 8 0.130 2-way 7 0.129 8 0.138 SCEN11 d-way 1474 6.095 585 2.418 2-way 325 2.161 264 1.768 Table 2.3 Résultats expérimentaux des problèmes queensknights-n-k. La figure 2.3 présente les résultats obtenues sur des instances de problèmes aléatoires. Chaque point représente une instance aléatoire particulière. En abscisse, on trouve les temps de calculs (puis les nombre de backtracks) pour l heuristique min dom et en ordonnée, ceux pour cette même heuristique avec branchement binaire. 2.1.4 Discussion Les résultats obtenus sur le problème des Queens and Knights s explique par le fait que le branchement binaire va permettre de remettre en cause les variables choisies plus souvent. Bien que sélectionner une variable nécessite un petit peu de temps de calcul (calcul du critère, du minimum, etc.), le schéma de branchement binaire peut être profitable. Dans cet exemple, comme on ne bénéficie pas de beaucoup d information initialement, les heuristiques dirigées par les conflits choisiront au départ les reines ; c est seulement au fil de la recherche que ces heuristiques disposeront de suffisamment d informations pour sélectionner les cavaliers. En utilisant des branchements binaires, on remet en cause plus tôt les choix initiaux réalisés lorsqu on ne disposait pas d information. Ainsi, progressivement, en fonction des informations collectées, on remonte en haut de l arbre de recherche les variables impliquées dans le plus grand nombre de conflits. Les résultats obtenues pour le problème Radio Link Frequency Assignment montre qu il est presque toujours profitable de choisir un schéma de branchement binaire sur ce 22

Figure 2.3 Comparaison de l heuristique min dom avec des branchements non binaires (en abscisse) et binaires (en ordonnée) sur différentes instances aléatoires type de problème. Cependant, comme le montre les résultats expérimentaux présentés figure 2.3, le choix d un schéma de branchement binaire peut parfois être désavantageux. En effet, on constate ici qu un simple branchement binaire ne permet pas d améliorer l efficacité de la recherche de solution sur certaines instances de ce type de problème et au contraire, dégrade les performances. Ainsi, il y a certain problème où il est moins avantageux de choisir un schéma de branchement binaire. Il semblerait que les informations collectées au cours de la recherche grâce aux compteurs weight ne suffisent pas à guider la recherche efficacement. 23

2.2 Stratégie de redémarrage Une autre idée pour pallier au manque d informations au début de la recherche est de mettre en place une stratégie de redémarrage. Cette section présente différentes stratégies de redémarrage : cette partie s appuient essentiellement sur les travaux de [11] et [10]. 2.2.1 Présentation Les stratégies de redémarrage permettent d effectuer les choix des premières variables avec davantage d informations au fur et à mesure des redémarrages. On propose de suivre deux méthodes principales pour combiner l heuristique min dom et les redémarrages. Dans les deux méthodes, dans un premier temps, les redémarrages apparaissent après un nombre fixé d échecs (on peut également considérer plutôt le nombre de nœud comme dans [10]). La raison pour laquelle on se base sur le nombre d échecs est qu il reflète la quantité d information collectée. On notera C (pour Cutoff ) le nombre maximal d échecs avant coupure. De plus, on garde l information collectée lors de chaque exécution, c està-dire on ne réinitialise pas les poids des contraintes (les compteurs weight) à chaque redémarrage. On appellera dans la suite run une exécution de recherche de solution et on notera R le nombre de runs ce qui correspond à R 1 redémarrage. Si une solution est trouvée ou si on a réussi à prouver qu il n y a pas de solution avant le dernier run, l algorithme s arrête. Dans le cas contraintes, lorsqu on arrive au run final, on laisse la recherche se poursuivre jusqu au bout, c est-à-dire on fixe C = pour la dernière exécution, ce qui rend la méthode complète. Stratégie de collecte d information Même s il est possible de trouver une solution avant l exécution du dernier run, les R 1 premiers runs correspondent plutôt à une phase de collecte d information (apprentissage des poids des contraintes). Cette section présente deux approches différentes pour cette première phase. La première méthode, appelé aussi WTDI (pour Weighted Information Gathering) utilise uniquement l heuristique min dom pour guider la rechercher à chaque exécution. Comme les poids évoluent, l heuristique sera susceptible de visiter des parties différentes de l espace de recherche à chaque redémarrage puisque l ordre d assignation des variables pourra être différent. La seconde méthode, appelé aussi RNDI (pour Random Information Gathering) utilise l heuristique min dom uniquement pour guider la rechercher du run final. Pour les R 1 premiers runs, les variables sont sélectionnées aléatoirement à chaque point de choix (on parle aussi de Random Probes ou preuves aléatoires). Les poids des contraintes sont quant à eux incrémentés de la manière habituelle, c est-à-dire lorsque la propaga- 24

tion d une contrainte provoque un échec. L intérêt de l utilisation d un ordre aléatoire est de pouvoir collecter des informations de parties diversifiées de l espace de recherche. Ainsi, en explorant des parties variées, on obtient alors un meilleur échantillon d information pour identifier les différentes parties difficiles d un problème. On peut noter également que contrairement à la méthode WTDI, on ne s attend pas résoudre le problème avant le run final avec la méthode RNDI. Les R 1 premiers runs ont plus pour vocation de collecter des informations variées. Stratégie de coupure Jusqu à maintenant, la stratégie de coupure employée était constante : on fixait initialement C qui restait le même pour les R 1 premiers runs. Les travaux présentés dans [8] présentent notamment une nouvelle stratégie : C n est plus le même pour chaque redémarrage et suit une progression géométrique. En notant C i le nombre d échecs maximal autorisés au run i avant redémarrage et q la raison de la progression géométrique, on a alors la relation de récurrence : C i+1 = q C i. De plus, on fixera C 0. En pratique, il a été montré que les valeurs de q telle que q ]1; 2[ sont les plus efficaces. On peut justifier une telle stratégie pour la méthode WTDI en supposant qu initialement, on ne dispose pas de beaucoup d information, donc les premiers choix seront probablement mauvais et donc redémarrer rapidement permet de recommencer une recherche avec des premiers choix un peu meilleurs. Au fur et à mesure qu on dispose d information, les choix initiaux effectués seront de meilleure qualité et donc la recherche aura de meilleures chances d aboutir. Pour la méthode RNDI, une stratégie avec C constant semble plus adaptée puisqu on explore l espace de recherche sans tenir compte des informations collectés lors des n 1 premiers runs. De plus, collecter la même quantité de données pour chaque partie de l espace de recherche exploré semble plus cohérent (pour ne pas favoriser de région particulière de l espace de recherche). 2.2.2 Étude expérimentale des paramètres Trouver les bons paramètres est une chose délicate. Cette section propose une brève étude expérimentale des paramètres : le nombre de runs maximum R et le nombre maximal de backtracks avant coupure C. Le but est ici d observer l influence de ces paramètres sur différents problèmes. On notera que les résultats présentés ici sont les résultats moyens obtenus pour 5 exécutions. Les tableaux 2.4 et 2.5 présentent les résultats obtenus sur une instance modifiée de l instance 11 du problème Radio Link Frequency Assignment présenté précédemment. On rappelle les résultats avec simplement l heuristique min dom obtenus précédement : 8597 backtracks en 27.99 secondes. On remarque sur le tableau 2.4 qu une coupure trop 25

tard ou qu un nombre de redémarrage trop grand ne sont pas bénéfiques pour la stratégie WTDI. De plus, les paramètres tels que C [10; 40] et R [25; 100] donnent de bon résultats. Sur le tableau 2.5, on remarque que la stratégie RNDI semble beaucoup plus sensible au paramétrage. Les paramètres C et R semblent offrir une recherche plus efficace lorsque : (C; R) {(50; 80), (100; 20), (200; 10), (200; 20), (200; 40)} Nombre de backtracks Nombre de runs 10 20 40 80 160 25 6.570 s 1.498 s 2.234 s 3.997 s 7.477 s 2202 btks 665 btks 1191 btks 2233 btks 4301 btks 50 1.313 s 1.983 s 3.565 s 6.894 s 12.764 s 660 btks 1157 btks 2196 btks 4217 btks 8302 btks 100 1.941 s 3.402 s 6.454 s 12.445 s 23.414 s 1158 btks 2156 btks 4179 btks 8236 btks 16308 btks 200 3.581 s 6.456 s 11.320 s 23.871 s 47.325 s 2167 btks 4177 btks 8192 btks 16232 btks 32311 btks Table 2.4 Résultats expérimentaux en secondes et en nombre de backtracks total (btks) avec différents paramètres pour la stratégie WTDI sur l instance SCEN11-F10. Nombre de backtracks Nombre de runs 10 20 40 80 160 25 64.855 s 43.483 s 50.174 s 19.342 s 11.542 s 18741 btks 13483 btks 15915 btks 7136 btks 6686 btks 50 23.821 s 31.966 s 23.796 s 7.747 s 16.757 s 7682 btks 11299 btks 8352 btks 4774 btks 10067 btks 100 39.428 s 7.955 s 16.959 s 10.205 s 18.696 s 12988 btks 3657 btks 7379 btks 8309 btks 16401 btks 200 7.312 s 4.217 s 8.232 s 21.121 s 30.484 s 3636 btks 4261 btks 8320 btks 17898 btks 32845 btks Table 2.5 Résultats expérimentaux en secondes et en nombre de backtracks total (btks) avec différents paramètres pour la stratégie RNDI sur l instance SCEN11-F10. La figure 2.4 présente les résultats obtenus sur une instance de problème aléatoire. On remarque tout de suite qu il semble difficile de trouver un bon paramétrage. Les paramètres sur ce type de problème ne semble pas avoir beaucoup d influence sur la performance de la recherche. 26

27 Figure 2.4 La première ligne concerne la stratégie WTDI et la seconde concerne la stratégie RNDI. Les graphiques de droite sont les résultats expérimentaux en utilisant en plus une stratégie géométrique : on étudie les paramètres raison (q) et nombre de backtracks initial (C0) avec un nombre de runs fixé à 50.

2.2.3 Discussion Les résultats expérimentaux obtenus sur le problème de Radio Link Frequency Assignment présentent des caractéristiques propres à chaque stratégie de redémarrage. En ce qui concerne WTDI, elle semble moins sensible au paramétrage. En effet, en faisant l hypothèse qu on choisisse un nombre de backtracks avant coupure grand, il est davantage possible que l un des R 1 premiers runs trouve une solution ce qui réduit l importance du nombre maximal de runs. En fait, si le nombre de backtracks avant coupure est trop grand ( C ), on retrouve l heuristique min dom décrite dans les sections précédentes. C est alors qu ajouter une stratégie géométrique pour le nombre de backtracks avant coupure semble intéressant. En effet, en augmentant progressivement le nombre maximum de backtracks à chaque nouveau run, on augmente nos chances de trouver une solution tout de suite, d autant plus qu on bénéficie au fur et à mesure des informations collectées précédemment, ce qui rend la recherche chaque fois plus efficace. Les premiers runs, peu informés, servent alors principalement à collecter des informations rapidement. Puis, plus on dispose d information, plus l heuristique min dom fera des choix qui sembleront efficaces et plus elle aura de chances de trouver une solution sous condition qu on lui permette suffisamment de backtracks. C est pourquoi cette stratégie WTDI géométrique nous semble intéressante. Pour la stratégie RNDI, puisque la recherche de solution des R 1 premiers runs n utilise que des heuristiques aléatoires, le but est alors de trouver les paramètres permettant d explorer le plus possible et de manière variée l espace de recherche. Dans ce cas, les paramètres semblent plus délicats encore à régler. Il s agit de trouver un bon compromis entre les deux paramètres : un nombre de backtracks avant coupure suffisamment grand pour permettre de collecter suffisamment d informations intéressantes et un nombre de runs suffisamment grand pour collecter des informations variées dans l espace de recherche sans que ces deux paramètres soient trop grands pour ne pas perdre trop de temps lors des R 1 premiers runs qui forment une phase essentiellement d apprentissage et n ont pour but que de collecter des données. C est seulement le dernier run qui a véritablement pour vocation de trouver une solution plus ou moins efficacement en fonction de la quantité et de la qualité des données collectées. En ce qui concerne les instances de problèmes aléatoires, on s aperçoit que trouver un paramétrage qui donne de meilleurs résultats est une chose délicate. De plus, la stratégie RNDI géométrique est difficile à justifier puisque la phase d apprentissage utilise des heuristiques aléatoires, sans tenir compte des informations collectées précédemment. On s aperçoit ici des difficultés de paramétrage. Néanmoins, la stratégie WTDI géométrique nous semble plus robuste et facile à paramétrer, c est pourquoi nous la choisiront préférentiellement dans nos applications à des problèmes de trafic aérien. Enfin, on pourrait améliorer encore les performances par exemple en stockant des nogoods, c est-à-dire des solutions partielles menant à un échec comme proposé dans [16]. Chaque redémarrage bénéficierait alors des nogoods collectés précédemment. 28

2.3 Heuristique Last Conflict Cette section présente une heuristique adaptative intéressante. Elle reprend les travaux présentés dans [15]. 2.3.1 Présentation de l heuristique L heuristique présentée dans [15] propose une nouvelle approche pour guider la recherche vers la source des conflits : l heuristique Last Conflict. Cette heuristique a l avantage de pouvoir être couplée à n importe quelle autre heuristique de choix de variable. Cette heuristique s intéresse aux raisons qui ont conduit à un conflit. Un échec, une impasse dans l arbre de recherche, correspond à un conflit entre un sous-ensemble de décisions : on entend par décision une assignation de variables (définition 4). Ainsi, il est intéressant d identifier la décision la plus récente qui participe au conflit. Il est alors possible d effectuer indirectement un retour-arrière sur la variable qui a mené à la dernière impasse rencontrée : cette variable devient la prochaine variable à sélectionner en priorité. Cette approche à donc pour but de guider la recherche de manière à détecter dynamiquement la raison du dernier conflit rencontré. 2.3.2 Algorithme Les deux définitions suivantes sont essentielles pour la description de l algorithme. Definition 6. Soient P un réseau de contrainte et un ensemble de décision. est un nogood de P si et seulement si P est instatisfiable. Definition 7. Soient P un réseau de contrainte et = δ 1,..., δ i une séquence de décisions telle que {δ 1,..., δ i } est un nogood de P. Une décision δ j est dite coupable si et seulement si, il existe v dom (X i ) où X i représente la variable impliquée dans δ i, tel que la propagation des contraintes du réseau P δ1,...,δ j 1, δ j,x i =v n échoue pas. L heuristique Last Conflict est un raisonnement à partir du dernier conflit. L algorithme repose essentiellement sur une simple modification de l heuristique de choix de variable afin d identifier et d exploiter les nogoods. On peut décrire l algorithme en deux étapes essentielles et suffisantes : enregistrement de la variable dont l assignation a mené directement à une inconsistance ; sélection de cette variable en priorité dans les décisions suivantes plutôt que celle proposée par l heuristique de choix de variables. On remarque également qu on n a pas besoin de structure de donnée supplémentaire. 29

2.3.3 Reprise de l exemple illustration des Queens and Knights On expérimente d abord sur l exemple illustratif 1.3.2 des Queens and Knights. Le tableau 2.6 présente les résultats obtenus en combinant l heuristique Last Conflict avec différentes heuristiques. Afin de pouvoir comparer, on rappellera également les résultats obtenues lors des premières expériences de la section 1.3.2. On s aperçoit de l intérêt de l heuristique Last Conflict en particulier sur les heuristiques classiques min dom et min dom dom ddeg. L heuristique Last Conflict combinée avec max et min améliore également les performances dans une moindre mesure sur ce type de problème. Ces résultats s expliquent par le fait que, petit à petit, les variables qui font partie du problème des cavaliers vont remonter dans l arbre de recherche grâce à l heuristique Last Conflict (on suit le principe fail-first). Afin d aider à comprendre les résultats obtenus, on remarque enfin que les heuristiques dirigées vers les conflits remontent également naturellement les variables des cavaliers : l heuristique Last Conflict ne fait donc qu accélerer cette remontée. instance min dom min dom ddeg max min dom LC LC LC LC LC LC LC LC qk-8-5 6049 207 6049 267 717 267 726 267 4.235 s 0.132 s 4.247 s 0.138 s 0.499 s 0.176 s 0.499 s 0.190 s qk-8-5 v 5305 198 5305 198 696 256 1091 256 4.496 s 0.202 s 4.477 s 0.215 s 0.718 s 0.263 s 1.004 s 0.262 s qk-10-5 75181 710 75181 710 2309 717 2863 623 86.198 s 0.865 s 87.281 s 0.883 s 2.735 s 0.843 s 3.349 s 0.721 s qk-10-5 v 67893 674 67893 674 2250 681 2901 597 96.903 s 1.106 s 96.223 s 1.132 s 3.934 s 1.102 s 4.773 s 0.986 s qk-12-5 895 895 4918 884 6141 1018 > 300 s 1.607 s > 300 s 1.643 s 8.977 s 1.632 s 10.898 s 1.895 s qk-12-5 v 873 873 4830 859 6474 991 > 300 s 2.396 s > 300 s 2.275 s 13.074 s 2.243 s 16.313 s 2.553 s Table 2.6 Résultats expérimentaux des problèmes queensknights-n-k. 2.3.4 Expérimentation complémentaire Les résultats obtenus sur le problème des cavaliers montrent qu il peut être également intéressant d expérimenter l heuristique Last Conflict sur les heuristiques dirigées vers les conflits mais également sur des heuristiques classiques. C est pourquoi, le cas échéant, on comparera également les résultats avec l heuristique min dom ddeg. Les figure 2.5 et 2.6 présentent les résultats obtenues sur des instances de problèmes aléatoires. Chaque point représente une instance aléatoire particulière. Sur la figure 2.5 (respectivement figure 2.6), on trouve en abscisse les temps de calculs (puis les nombres 30

de backtracks) pour l heuristique min dom dom ddeg (respectivement min ) et en ordonnée, ceux pour cette même heuristique avec l heuristique Last Conflict. Figure 2.5 Comparaison de l heuristique min dom ddeg (en abscisse) et cette même heuristique avec Last Conflict (en ordonnée) sur différentes instances aléatoires. Le tableau 2.7 présente les résultats obtenus sur des instances du problème Radio Link Frequency Assignement avec différentes heuristiques. Afin de pouvoir comparer, on rappelle également les résultats obtenus dans la section 1.3.3 sans Last Conflict (noté LC ). 2.3.5 Discussion L exemple des Queens and Knights montre un aspect intéressant de l heuristique Last Conflict : une fois une inconsistance découverte, l heuristique va tenter d instancier la variable qui a causé le conflit au plus tôt. Cette heuristique est peu onéreuse en temps de calcul et en utilisation mémoire. On peut remarquer également qu elle imite en quelque sorte des mécanismes de retour-arrière intelligent plus complexes tels que les techniques de Back-Jumping qu on trouve dans la littérature par exemple. L article?? montre en effet que lorsqu on utilise des heuristiques dirigées vers les conflits, les techniques de retour-arrière intelligent n ont plus beaucoup d intérêt lorsqu elles sont appliquées aux CSP statiques. Les résultats obtenus sur le problème Radio Link Frequency Assignement montre l intérêt de l heuristique Last Conflict notamment sur l instance 11. On notera également que l heuristique classique min dom ddeg couplée avec l heuristique Last Conflict obtient des résultats similaires aux autres heuristiques. 31

Figure 2.6 Comparaison de l heuristique min dom (en abscisse) et cette même heuristique avec Last Conflict (en ordonnée) sur différentes instances aléatoires. En ce qui concerne les instances de problème aléatoire, on remarque que peu importe l heuristique de choix de variable initiale, l heuristique Last Conflict détériore nettement les performances. Cette heuristique présente l avantage de pouvoir être couplée à n importe quelle autre heuristique de choix de variables. Les résultats expérimentaux montrent nettement l intérêt de cette approche, notamment lorsqu on utilise une heuristique de choix de variables classique comme min dom ou min dom ddeg dirigée par les conflitcs comme max ou min dom. Lorsqu on l utilise avec une heuristique, les résultats sont plus mitigés. À noter également que sur certains types de problèmes, l heuristique Last Conflict peut améliorer les résultats comme les détériorer. 32

instance min dom ddeg max min dom LC LC LC LC LC LC SCEN-1 55 55 54 54 55 55 0.606 s 0.716 s 0.605 s 0.674 s 0.626 s 0.769 s SCEN-2 3 3 1 1 3 3 0.070 s 0.070 s 0.067 s 0.067 s 0.068 s 0.076 s SCEN-3 13 13 13 13 13 13 0.228 s 0.219 s 0.218 s 0.214 s 0.219 s 0.248 s SCEN-4 48 48 89 89 48 48 0.294 s 0.303 s 0.316 s 0.339 s 0.289 s 0.326 s SCEN-5 8 8 7 7 8 8 0.134 s 0.133 s 0.128 s 0.127 s 0.130 s 0.130 s SCEN-11 96251 180 1474 213 585 188 294.869 s 1.025 s 6.095 s 1.110 s 2.418 s 1.063 s Table 2.7 Résultats expérimentaux des instances du problème Radio Link Frequency Assignement 2.4 Une hybridation avec de la recherche locale Les algorithmes de résolution se divise en deux grandes familles : les algorithmes systématiques et les algorithmes non-systématiques. Bien que les algorithmes non-systématiques soient généralement incomplets, ils sont adaptés aux problèmes satisfiables de très grande taille, impossible à résoudre en un temps raisonnable par des méthodes systématiques. Ces algorithmes non-systématiques regroupe la recherche locale, les algortihmes évolutionnaires, les colonies de fourmis, les algorithmes gloutons, etc. Cette partie présente une idée développée dans [19] qui a pour but d hybrider les deux types d algorithmes : recherche locale et recherche systématique. Cette partie décrit une tentative d hybridation simplifiée qu on a implémentée et testée uniquement sur des contraintes binaires en extension. Compte tenu du temps imparti pour ce stage, le but sera alors d explorer et de comprendre la méthode pour se rendre compte de son potentiel et les ouvertures possibles liées à l heuristique Weighted Degree. 2.4.1 Introduction à la recherche locale Cette section présente de manière simple une approche pour résoudre les problèmes de satisfaction de contraintes de taille importante. Cette section s inspire également des travaux de [17]. 33

Recherche locale Min-Conflicts Les algorithmes systématique se base sur une approche constructive qui étend incrémentalement une instanciation partielle des variables et utilise, le cas échéant, une stratégie de retour-arrière (backtrack). En revanche, la recherche locale crée une affectation complète mais inconsistante des variables puis répare les violations de contrainte jusqu à l obtention d une affectation consistante. Une réparation consiste en général à modifier la valeur assignée à une variable. L instanciation initiale des variables peut être générée aléatoirement. Il est également possible d initialiser les variables avec un algorithme glouton qui cherchera à minimiser les conflits dès l instanciation. Par exemple, un réseau de contrainte possédant au moins deux variables v i et v j liée par une contrainte de la forme v i + v j = 5, si on suppose que l on ait déjà initialisé v i à 2, l algorithme glouton pourra choisir alors d instancier v j à 3 pour minimiser les conflits alors qu une initialisation aléatoire aurait choisi n importe quelle valeur. Afin de guider la recherche, on utilisera une heuristique de choix de variable simple : l heuristique Min-Conflicts. Cette heuristique identifie d abord une variable en conflit, c est-à-dire qui est liée à une contrainte violée, puis choisit une valeur qui minimise le nombre de violations de contrainte. Une procédure la caractérisant est proposée dans [14] : Heuristique Min-Conflicts : Donnée : un ensemble de variables, un ensemble de contraintes binaires et une instanciation spécifiant une valeur pour chaque variable. Deux variables sont en conflit si leurs valeurs violent une contrainte. Procédure : Sélectionner une variable qui est en conflit et lui assigner une valeur qui minimise le nombre de conflits. On remarque également que cette méthode ne garantie pas de trouver une solution (méthode incomplète) et ne permet pas non plus de prouver qu un problème est insatisfiable. Minimums locaux Il est possible qu aucune réparation simple, c est-à-dire assigner une autre valeur à une variable, ne puisse diminuer le nombre de violations de contrainte. On a alors atteint un minimum local. Cette partie présente principalement deux techniques pour échapper aux minimums locaux utilisées dans [19]. La première idée simple, proposée dans [17], consiste à effectuer des mouvements aléatoires. Une réparation est effectuée aléatoirement avec une probabilité p au lieu d être choisie parmi les meilleures réparations. On appelera cette méthode pour échapper aux minimums locaux Random Walk (marche aléatoire). Cette méthode est illustrée par l algorithme 1. 34

Algorithm 1 Min-Conflict avec Random Walk 1: tant que nombre de violations de contrainte > 0 faire 2: sélectionner aléatoirement X tel que X est en conflit 3: si random[0; 1] < p alors 4: sélectionner une valeur v de X aléatoirement 5: sinon 6: sélectionner une valeur v de X qui minimise le nombre de conflits 7: fin si 8: affecter v à X 9: mise à jour des violations de contrainte 10: fin tant que Une seconde idée consiste à éviter de revenir à une affectation déjà visitée en enregistrant les réparations précédentes. Cette technique utilise une structure de donnée appelée liste Tabu proposé dans [7]. Cette liste garde en mémoire les réparations effectuées mais la taille de cette liste est limitée de sorte qu un nombre limité de réparations est gardé en mémoire et que les plus anciennes sont oubliées. Ainsi, un grand nombre de réparation reste disponible. On peut également définir un critère, appelé critère d aspiration, tel qu on puisse choisir une réparation présente dans la liste Tabu si celle-ci permet d obtenir une meilleure affectation que toutes celles rencontrées jusqu à présent. Cette méthode Tabu est illustrée par l algorithme 1. Algorithm 2 Min-Conflict avec Liste Tabu, avec L tabu la liste Tabu 1: tant que nombre de violations de contrainte > 0 faire 2: sélectionner un couple (X, v) tel que X est en conflit et v est une valeur de X qui minimise le nombre de conflits, et tel que (X, v) L tabu ou valide le critère d aspiration 3: insérer le couple (X, v) dans L tabu et supprimer le plus ancien élément 4: affecter v à X 5: mise à jour des violations de contrainte 6: fin tant que Exemple illustratif Afin de bien comprendre comment marche une recherche locale, on détaillera un exemple de déroulement de l algorithme Min-Conflicts sur le problème des 4-Queens. On considère qu on affecte une colonne à chaque reine et on lui associe une variable indiquant son numéro de ligne. On suppose qu on a posé toutes les contraintes nécessaires. Le tableau 2.8 présente l initialisation gloutonne décrite précédemment : une première valeur est affectée aléatoirement à la première variable (ici 0) ; puis, on compte le nombre de conflit pour chaque valeur que peut prendre la variable (que l on a noté sur l échiquier) ; on sélectionne aléatoirement une valeur minimisant le nombre de conflit ; on compte à 35

nouveau le nombre de conflit, etc. 1 1 0 0 1 1 2 1 3 1 2 1 Table 2.8 Illustration de l initialisation gloutonne sur le problème des 4-Queens. Le tableau 2.9 présente le déroulement de l algorithme. On démarre de l affectation précédente. Dans la première colonne du tableau 2.9, on note le nombre d itérations ; dans la deuxième colonne, on note en dessous de l échiquier, le nombre de conflits pour chaque variable ; dans la troisième colonne, on note sur l échiquier le nombre de conflits si on effectuait la réparation et à droite de l échiquier la variation du nombre de conflits par rapport à l état courant si on effectuait la réparation ; dans la dernière colonne, on présente le résultat obtenu une fois la réparation effectuée. À la fin, on obtient bien une solution consistante. Comme on l a dit précédemment, les algorithmes de recherche locale semblent plus efficaces sur des problèmes de grande taille. La figure 2.9 présentent les résultats obtenus (en temps de calcul) sur l exécution du problème des n-queens avec un algorithme de recherche locale avec méthode Tabu et un algorithme de recherche systématique (parcours d arbre en profondeur d abord et retour-arrière) avec une heuristique de choix de variable min dom. On remarque que la recherche locale est plus robuste face à l augmentation du nombre de reines. On notera que cet exemple à pour simple but d illustration. La modélisation n est faite que de contraintes binaires. Une modélisation avec des contraintes globales tel que Alldiff 1 donnerait de meilleurs résultats, notamment pour la recherche systématique. 2.4.2 Hybridation séquentielle Cette section se base sur les travaux de [19]. Elle présente une manière d hybrider séquentiellement une recherche locale et une recherche systématique en partageant des 1. All-Different : cette contrainte globale impliquent que les variables sur lesquelles elle est définie prennent des valeurs deux à deux différentes. 36

itérations sélection d une variable sélection d une valeur réparation 1 2 0 0 1 2 1 3 1 0 1 2 1 +1-1 2 1 2 0 +1 0 1 1 0 2 0 1 1 0 +1 3 1 1 0 0 3 0 1 1 1 0 0 +2-1 0 Table 2.9 Exécution de l algorithme Min-Conflict sur le problème des 4-Queens. informations. Recherche locale Weighted Min-Conflict L hybridation présentée se base sur un partage d information entre recherche systématique et recherche locale. L information que l on va partager sont les compteurs weight présentés précédemment et exploités par l heuristique Weighted Degree. Cette section présente comment sont exploités ces poids par la recherche locale. Une méthode consiste à pondérer les contraintes. Cette idée a été développée dans [18]. En considérant une version idéalisée de cette méthode, on suppose que chaque état possède un coût enregistré en mémoire. L algorithme 2.10 illustre cette méthode. Augmenter le coût des états qui ont mené à un minimum local permet de lisser les 37

Figure 2.7 Comparaison de l heuristique min dom avec une recherche locale Min- Conflict avec Liste Tabu. Algorithm 3 Breakout Method 1: tant que l état courant n est pas une solution faire 2: si l état courant n est pas un minimum local alors 3: faire une modification local qui réduisse le coût 4: sinon 5: augmenter le coût enregistré de l état courant 6: fin si 7: fin tant que minimums locaux et de les éliminer efficacement. La figure 2.10 présente un exemple de cette méthode. Il est irréaliste d enregistrer en mémoire pour chaque état un coût. Néanmoins, on peut reproduire ce mécanisme en pondérant les contraintes. Si un minimum local est détecté, on augmente alors le poids (c est-à-dire le compteur weight) de toutes les contraintes en conflit (ce qui reproduit une augmentation du coût enregistré de l état courant). En pondérant ainsi les contraintes, les contraintes les plus difficiles à satisfaire, celle qui sont le plus souvent violées, auront peu à peu un poids plus important. L algorithme de recherche locale cherchera donc à les satisfaire en priorité puisque les satisfaire engendre une réduction plus importante du coût. L algorithme 4 illustre cet algorithme de recherche locale que l on appellera Weighted Min-Conflict. 38

Table 2.10 Illustration du lissage d un minimum local par pondération des contraintes violées Algorithm 4 Weighted Min-Conflict 1: tant que nombre pondéré de violations de contrainte > 0 faire 2: sélectionner aléatoirement X tel que X est en conflit et une valeur v de X qui minimise le nombre pondéré de conflits 3: si la réparation où on affecte v à X n améliore pas le coût de l état courant alors 4: augmenter le poids des contraintes violées 5: sinon 6: affecter v à X 7: mise à jour des violations de contrainte 8: fin si 9: fin tant que On remarque enfin qu il arrive que de très mauvais choix initiaux orientent la recherche vers de larges zones de l espace de recherche sans solution ou qu il faille un nombre important de réparations pour passer d un minimum local à un autre. Pour éviter ces problèmes, le meilleur moyen reste parfois de réparer toutes les variables simultanément en reprenant simplement la recherche du début. C est pourquoi on fixera un nombre maximum d itérations à l algorithme Weighted Min-Conflict avant de redémarrer la recherche de solution. Hybridation des deux types de recherche L hybridation qu on a réalisée reprend seulement l idée principale de [19]. On n enregistre pas par exemple les nogoods découverts lors de la recherche systématique. En théorie, cette méthode d hybridation permet de résoudre des problèmes au-delà de la portée de chacune des deux méthodes hybridées en exploitant les performances des deux 39

approches. La recherche systématique (RS) se base sur celle développée dans les sections précédentes. On rappelle qu il s agit donc d un parcours d arbre en profondeur d abord avec retour-arrière et maintien de la consistance d arc. On utilise également l heuristique de choix de variable min dom. Le paramètre nbbacktracks max permet d interrompre la recherche en limitant le nombre maximum de backtracks. La recherche locale utilisée est Weighted Min-Conflict (WMC ) que l on aide d une liste Tabu pour sortir plus facilement des minimums locaux. On interrompt également la recherche grâce à un paramètre nbiterations max qui limite le nombre maximum d itérations. Le partage d information entre les deux recherches se fera de manière naturelle sur les poids (compteur weight) des contraintes incrémentés lorsqu une propagation conduit à un échec pour la recherche systématique d une part et lorsqu on se trouve dans un minimum local pour la recherche locale d autre part. Enfin, si jamais l une des recherches trouve une solution, l algorithme s arrête et retourne cette solution. La figure 2.8 illustre l hybridation séquentielle des deux types de recherche. Figure 2.8 Hybridation séquentielle des deux types de recherche. De plus, à chaque cycle (c est-à-dire une alternance recherche locale et recherche systématique), on augmentera les paramètres nbiterations max et nbbacktracks max suivant une lois géométriques de raison α. Afin de partager les ressources entre les deux types de recherche, on chronomètre chacune des deux recherches pour rééquilibrer dynamiquement le temps alloué à chacune d entre elles. L algortihme 5 illustre de manière simplifiée l hybridation mise en oeuvre. 40

Algorithm 5 Hybrid 1: tant que on n a pas trouvé de solution faire 2: t debut maintenant() 3: redémarrer nbredemarrages max une recherche locale Weighted Min-Conflict limitée à nbiterations max itérations. 4: t W MC maintenant() t debut 5: effectuer une recherche systématique limitée à nbbacktracks max. 6: t RS maintenant() t RNS 7: nbredemarrages max α nbredemarrages max 8: nbbacktracks max α nbbacktracks max t W MC t RS 9: fin tant que 2.4.3 Expérimentation On a essentiellement trois paramètres à régler : le coefficient α, la longueur de la liste Tabu que l on notera l tabu et le nombre maximum d itérations nbiterations max. Trouver les bons paramètres semble délicat et fortement lié au problème à résoudre. De plus, notre première implémentation n est pas suffisamment mature pour présenter une étude détaillée des paramètres. C est pourquoi, on se contentera simplement d un aperçu de l importance de chacun de ces paramètres. On a testé notre implémentation uniquement sur des instances de problème aléatoire testées 5 fois avec le même paramétrage. Afin de pouvoir visualiser graphiquement nos résultats grâce à un graphique en 3 dimensions, on fixera dans un premier temps l tabu = 50. Dans un second temps, compte tenu de la difficulté de lecture des courbes en 3 dimensions 2, on fixe également nbiterations max = 2000. La figure 2.9 présente les résultats obtenus. On s aperçoit alors que dans ce cas, une valeur de α entre 1,5 et 2 donne de meilleurs résultats. Comme le montre la figure 2.10, on peut également faire de même en fixant d abord arbitrairement nbiterations max = 2000 puis fixer α entre 1,5 et 2 puisque cela correspond aux meilleurs résultats obtenus précédemment. On constate qu une taille de liste Tabu d environs 50 est plutôt un bon choix. Enfin, les résultats de la figure 2.11 ont été élaborés en fixant d abord α = 1, 75 puis l tabu = 50 pour permettre une meilleur visualisation des résultats puisque cela correspond aux valeurs sélectionnées précédemment. On s aperçoit alors que fixer initialement nbiterations max à 2000 est une valeur moyenne acceptable. 2. Les courbes en 3 dimensions présentées ici sont reproduit en format plus grand en annexe. 41

Figure 2.9 Résultats obtenus en fixant l tabu à 50. nbiterations max = 2000 Il est possible de raffiner encore le réglage des paramètres mais il faut garder à l esprit qu il semble que les paramètres soient dépendants du problème : un bon paramétrage pour un problème n est pas forcément bon pour un autre. Enfin, en moyenne, en considérant ce paramétrage, il faut en moyenne à la méthode hybride 8,4 s contre 9,2 s à la méthode systématique avec l heuristique de choix de variable min dom pour obtenir une solution à des instances de problèmes aléatoires. 2.4.4 Discussion Le but de cette partie était avant tout de présenter l idée principale de l hybridation développée dans [19]. C est pourquoi on ne détaillera pas davantage et on ne testera pas sur d autres problèmes. Notre approche appliquée permet de se rendre compte des difficultés de paramétrage mais aussi du potentielle d une telle méthode. Néanmoins, notre implémentation n est pas assez mature et robuste. C est pourquoi, on ne testera pas cette hybridation sur des problèmes de trafic aérien. On retiendra essentiellement la séduisante manière naturelle d hybrider les deux méthodes qui ouvre d autres perspectives liées à l heuristique Weighted Degree. 42

α = 1.75 Figure 2.10 Résultats obtenus en fixant nbiterations max à 2000. Figure 2.11 Résultats obtenus en fixant l tabu à 1,75. l tabu = 50 43

Chapitre 3 Application à un problème de gestion du trafic aérien 3.1 Présentation de la gestion du trafic aérien La gestion du trafic aérien est nécessaire pour plusieurs raison : pour garantir des niveaux de sécurité, pour garantir un écoulement du trafic, pour optimiser l écoulement du trafic, etc. Cette gestion se fait à travers notamment le contrôle découpé en trois catégories principales : le contrôle en route qui est responsable des vols en croisière ; le contrôle d approche qui gère les avions aux alentours d un aéroport pendant leur phase de descente ou de montée ; le contrôle d aéroport qui est responsable de toute la phase aéroportuaire des vols, depuis la descente finale de l avion jusqu à son déollage suivant. Cette dernière phase comprend également le séquencement des avions sur la piste. Les dernières prévisions d Eurocontrol, organisme Européen de gestion du trafic aérien, prévoit une croissance du trafic aérien pour 2010 de 0.8% malgré le contexte de crise économique 1. L augmentation du trafic aérien implique notamment une amélioration de la capacité des aéroports : un dysfonctionnements peut aboutir à la congestion d un aéroport ce qui lourd de conséquences en terme économique, de retard et de sécurité. C est pourquoi, nous nous intéressons dans cette partie à résoudre un problème d optimisation du séquencement d avions au décollage et à l atterrissage d un grand aéroport en limitant les retards. Les problèmes de Job Shop Scheduling présentent des points communs avec les problèmes de séquencement d avion. C est pourquoi nous avons commencé par suivre la démarche de [9] dans la section 3.2 pour ensuite l adapter à notre problème aéroportuaire dans la section 3.3. La section 3.2 permet également de montrer l interêt de l utilisation de technique générique. 1. EUROCONTROL Short-Term Forecast, May 2010 44

3.2 Problème de Job Shop Scheduling Cette partie s inspire des démarches de [11] et [9]. 3.2.1 Présentation du problème Un problème de Job Shop de taille n m implique n jobs et m machines. Chaque job est constitué de m tâches à exécuter dans un ordre fixe, chacune sur une machine différente. Chaque tâche est ininterruptible et on associe une durée à chacune d entre elles. Chaque machine correspond à exactement une seule tâche par job et ne peut effectuer qu une seule tâche à la fois. Le but est alors de minimiser la durée totale pour effectuer toutes les tâches (makespan). La figure 3.1 présente un petit exemple de problème de Job Shop. On dispose ici de 3 jobs qui se partage 3 machines. Chaque machine est représenté par une couleur. L ordre dans le quel chaque tâche doit être effectué est symbolisé par un chemin de flèche pour chaque job. La figure 3.2 présente une solution optimale possible : pour chaque job, on donne l ordonnancement des différentes tâches. Il existe une autre variante de ce problème connu sous le nom de Open Shop : le problème est identique sauf que les tâches d un job ne sont plus ordonnée initialement. 3.2.2 Modélisation La modélisation présenté dans [9] semble intéressante : elle est à la fois simple et générique. Elle utilise des contraintes de disjonction simple et l heuristique Weigthed Degree. Pour chaque job, on modélise l heure de début de chacune des tâches par une variable t i. Puis, on fixe l ordre des tâches de chaque job par la contrainte t i + d i t j avec d i la durée de la tâche t i si la tâche i doit précéder la tâche j. Puis, pour chaque paire de tâches i et j non-ordonnées partageant la même machine, on introduit une variable booléenne b ij représentant l ordre entre les deux tâches, c est-à-dire si b ij vaut 0 alors la tâche i précède la tâche j et sinon, si b ij vaut 1, on considère l ordre opposé. Les variables b ij, t i et t j sont liées par la contrainte sur laquelle on maintien la consistance aux bornes : b ij = 0 t i + d i t j et b ij = 1 t j + d j t i On obtient alors mn(n 1) 2 contraintes de disjonction et autant de variables booléenne b ij. 45

Figure 3.1 Illustration d un problème de Job Shop où 3 jobs doivent utiliser 3 machines différentes dans un ordre défini. 3.2.3 Stratégie de recherche Afin de pouvoir expliquer d avantage notre modélisation et la stratégie de recherche utilisée, il faut rappeler une observation (mentionnée dans [9]) : l existance d un ordre partiel des tâches tel que les heures de début de tâche et les durées soient compatibles et tel que l ordre des tâches sur chaque machine soit un ordre total, est équivalent à l existence de solution. Autrement dit, la propagation est complète si toutes les disjonctions sont résolues. Ainsi, si on choisit les variables booléennes b ij comme variables de décision et si on arrive à assigner toutes ces variables, l existence de solution est garantie. C est pourquoi, au lieu de rechercher les solutions en assignant une valeur unique à l heure de début de la tâche sur la branche de gauche et d interdire cette valeur sur la branche de droite de l arbre de recherche, on va plutôt séparer le problème en relation de précédence. La modélisation proposée utilise cette stratégie et réduit ainsi significativement l espace de recherche. 46

Figure 3.2 Une solution optimale au problème de Job Shop de la figure 3.1. On utilise ensuite l heuristique Weighted Degree décrite section 1.3.1. On notera que le comportement de l heuristique est dépendant de la modélisation : deux ensembles de contraintes différents, bien qu équivalent, peuvent distribuer les poids de manière différente. Dans notre modélisation, chaque contraintes implique une seule variable de décision. Au début de la recherche de solution, l heuristique n est pas informée (toutes les variables booléennes ont le même poids de 1). On utilise alors la taille du domaine des deux tâches t i et t j associée à une variable booléenne b i,j pour informer la méthode de sélection jusqu à ce que les poids deviennent prédominants. On choisira alors la variable qui minimise la somme de la taille des domaines des deux tâches divisée par le poids de la contrainte de disjonction impliquant la variable de décision b ij (c est-à-dire le nombre de fois que la recherche échoue lors de la propagation de la contrainte). En notant w ij le poids de cette contrainte : D(t i ) + D(t j ) w ij L heuristique étant peut informée initialement, on effectue plusieurs redémarrage. Les poids des contraintes sont plus représentatifs des parties difficiles du problème à résoudre au fur à mesure des redémarrage ce qui permet d effectuer de meilleurs choix de variables initiales. La stratégie de redémarrage utilisé est similaire à celle évoqué dans la section 2.2.1. On coupe la recherche au bout d un nombre fixé de backtracks qui croît suivant une loi géométrique : à chaque redémarrage, on dispose de plus d information pour choisir les variables initiales alors on peut supposer que les choix de variables auront 47

plus de chance d aboutir vers une solution. Passé un nombre fixé de redémarrages, on enlève la stratégie de coupure pour le dernier redémarrage et on laisse la rechercher parvenir à son terme. 3.2.4 Expérimentation Nous avons expérimenté cette modélisation sur une instance énoncé par J.F. Muth et G.L. Thompson dans le livre Industrial scheduling (1963). Cette instance difficile a été résolu la première fois par J. Carlier et E. Pinson, An algorithm for solving the job-shop problem (1989). Le tableau 3.3 présente les résultats expérimentaux moyens obtenus pour chaque heuristique testée 5 fois. Il présente pour chaque technique le nombre total de backtracks pour prouver l optimalité de la solution, le temps de calcul pour trouver la meilleure solution et le temps de calcul pour trouver la meilleure solution et prouver son optimalité. Le paramétrage de la stratégie de redémarrage a été choisi après plusieurs expérimentations : le nombre de redémarrage est fixé à 100 et pour la progression géométrique de coupure, l élément initiale est fixé à 1 et la raison a 1.1. On testera également notre modèle avec une amélioration proposée précédemment, l heuristique Last Conflict présentée section 2.3. backtracks meilleure sol. (s) temps total (s) Edge Finding 105758 64,52 105,93 Weighted Degree 28290502 983,4 1459,16 Last Conflict et Weighted Degree 3780014 64,81 209,36 Figure 3.3 Résultats expérimentaux La figure 3.4 donne un aperçu du séquencement obtenue. Sur cette figure, chaque ligne correspond à un job et chaque couleur représente une même machine. 3.2.5 Discussion Les résultats obtenues montrent l intérêt de l étude des heuristiques de choix de variable et montre la diversité des performances. Avant de comparer les différentes techniques, il ne faut pas perdre de vue que les heuristiques Weighted Degree et Last Conflict sont des heuristiques génériques. La méthode de Edge-Finding (implémentée ici par P-S. Huard et détaillée par exemple dans [1], l ouvrage couvre également une analyse complète des différentes techniques de séquencement) est une technique spécifique de propagation de contrainte de ressource unitaire. Cette technique utilise des raisonnements globaux sur l ensemble des tâches affectées à une machine (il existe également des versions de cette algorithme pour 48

Figure 3.4 Une solution optimale d une instance énoncé par J.F. Muth et G.L. Thompson du problème de Job Shop. des ressource non unitaire). Il n est donc pas surprenant que cette technique soit la plus efficace. Ce qui est intéressant de voir ici, c est qu une approche utilisant un modèle plus simple et une heuristique générique peut approcher les résultats obtenus par une technique spécifique. Il est parfois difficile, long ou coûteux d obtenir l expertise nécessaire aux développement de techniques spécifiques à un problème. Le choix de modèle simple et d heuristique générique, bien qu un peu moins efficace, offre un bon compromis. C est pourquoi dans la suite, on testera une approche similaire sur un problème de trafic aérien. 49