TER de maîtrise d informatique Compte-rendu TER 11 Métaheuristique d un ordonnancement Juste à temps

TER de maîtrise d informatique Compte-rendu TER 11 Métaheuristique d un ordonnancement Juste à temps Arnaud Malapert Gildas Jeantet Université Pierre et Marie Curie 15/06/2005 1

Table des matières 1 Présentation générale du projet 4 1.1 Acronymes et définitions...................... 4 1.2 Présentation du problème...................... 5 2 La Conception théorique du projet 5 2.1 Les Méthodes de recherche..................... 5 2.1.1 La recherche locale..................... 6 2.1.2 La recherche tabou..................... 6 2.1.3 Le recuit simulé....................... 7 2.1.4 Les voisinages....................... 9 2.2 Le Sous-problème de la séquence fixée............... 12 2.2.1 Algorithme de programmation dynamique de Sourd.... 12 2.2.2 L exploration du voisinage................. 13 3 Conception des structures de données 13 3.1 Instance du problème........................ 13 3.2 Solution............................... 13 3.3 Méthodes de recherches....................... 13 3.3.1 Les recherches locales................... 14 3.3.2 Les listes tabou....................... 14 3.4 Sous-problème de la séquence fixée................ 14 3.4.1 Les fonctions linéaires par morceaux........... 17 3.4.2 Voisinage basée sur la permutation de deux taches consécutives........................... 17 3.4.3 Voisinage basée sur la permutation de deux taches quelquonques.......................... 18 3.4.4 Parcours de Voisinage................... 25 3.4.5 debugger.......................... 25 4 Conception de l interface graphique 25 5 Analyses et tests 27 5.1 Test sur le recuit........................... 27 5.2 Test sur le tabou........................... 28 5.3 Test sur la descente locale...................... 29 5.4 conclusion.............................. 29 6 Références Bibliographiques 31 2

Table des figures 1 Pseudo code RT........................... 7 2 Règle de Metropolis......................... 8 3 Pseudo code RS........................... 9 4 UML Algorithme.......................... 15 5 UML Séquence fixée........................ 16 6 les fonctions Σ............................ 19 7 calcul du coût d un voisin...................... 20 8 Un arbre binaire complet...................... 21 9 root et ses fils............................ 23 10 calcul de root............................ 24 11 UML Algorithme.......................... 26 Liste des tableaux 1 Définitions des termes........................ 4 2 Les Voisinages........................... 11 3 Algorithme de Sourd........................ 12 3

1 Présentation générale du projet 1.1 Acronymes et définitions Nous allons d abord introduire les acronymes utilisés dans la suite du texte : dasnod : Nom de l application. JAT : Juste A Temps. RT : méthode de Recherche Tabou ou méthode tabou. RS : méthode du Recuit Simulé ou méthode du recuit. SPS : Sous Problème pour une Séquence fixée. voisinage VC : un voisinage basée sur la permutation de deux tâches consécutives. voisinage VNC : un voisinage basée sur la permutation de deux tâches quelquonques. voisinage VNCE : un voisinage contenant le voisinage VC mais aussi d autres configurations car il a une structure de parcours de cycles(i.e. il parcours plusieurs cycles distincts). voisinage VEI : Ce voisinage a aussi une structure de parcours de cycles mais il visite le voisinage extraction insertion avec décalage à gauche. cycle : une liste ordonnée c de permutations telles que x l(x) = x. Nous allons maintenant définir certains termes relatifs au problèmes dans le tableau 1 page 4. Terme J = {J 1,...,J n } n = J p i r i d i S i C i α i β i f i (t) Définition L ensemble des tâches (jobs) le nombre de tâches la durée de la tâche J i (processing time) la date de début au plus tôt de la tâche J i (release date) la date échue à la tâche ou écheance J i (due date) la date de début de la tâche J i (start time) la date de fin de la tâche J i (completion time) la pénalité d avance la pénalité de retard la déviation de J i finissant en t TAB. 1 La définition des termes en relation avec les données, l ordonnancement et l optimisation. 4

1.2 Présentation du problème Le problème proposé présente un cas simplifié d ordonnancement JAT : il a pour but de montrer les difficultés liées à l optimisation de ce genre de critère. Néanmoins, ce problème de base apparaît trés souvent comme sous-problème d un problème plus complexe. La chaîne de production est ici modélisée par une seule machine (la machine critique) qui ne peut exécuter à un moment donné qu au plus une activité. Les activités à exécuter sont supposées toutes connues. Un ordonnancement O = {C 1,...,C n } est donc réalisable s il observe les trois contraintes suivantes : Pour chaque activité i on a : i {1,...,n} S i r i (1) i {1,...,n} p i = C i S i (2) i {1,...,n 1} S i+1 C i (3) f i (C i ) = { max(α i (d i C i ),β i (C i d i )) si C i r i + p i si C i < r i + p i Le but du problème est de trouver un ordonnancement réalisable minimisant la pénalité totale : n cout O = f i (C i ) i=1 existence d un ordonnancement de coût nul : d après nos hypothèses, le coût de chaque tâche est positif ou nul. Donc, s il existe un ordonnancement de coût nul chaque tâche a un coût nul, ce qui signifie qu elle termine à sa date d échéance si aucune des pénalités n est nulle. Bien qu on puisse Verifier à la main s il existe un ordonnancement de cout nul avec des pénalités nulles,nous considérerons que puisque cette étape peut faire intervenir une permutation de l ordre des tâches,elle doit être trouvée par nos méthodes de recherche. On peut donc verifier si l ordonnancement : i {1,...,N}, C j = d j est réalisable.cette opération peut se réaliser en O(N). 2 La Conception théorique du projet 2.1 Les Méthodes de recherche Le problème d ordonnancement JAT étant un problème NP-Complet, parcourir l ensemble de ses solutions pour en déterminer la meilleure, prendrait beaucoup 5

trop de temps (complexité en n!). C est pourquoi nous allons nous intéresser vers les algorithmes de Recherche Locale. 2.1.1 La recherche locale Cette famille d algorithme ne permet pas de trouver la meilleure solution (ou si elle est trouvée ne permet pas de le prouver), mais permet de trouver une bonne solution en un temps plus raisonnable. 2.1.2 La recherche tabou La recherche tabou est une métaheuristique d optimisation présentée par Fred Glover en 1986. On trouve souvent l appellation recherche avec tabous en français. Principe : L idée de la recherche tabou consiste, à partir d une position donnée, à en explorer le voisinage et à choisir la position dans ce voisinage qui minimise la fonction objectif. Il est essentiel de noter que cette opération peut conduire à augmenter la valeur de la fonction, c est le cas lorsque tous les points du voisinage ont une valeur plus élevée. C est à partir de ce mécanisme que l on échappe aux minima locaux. Le risque cependant est qu à l étape suivante, on retombe dans le minimum local auquel on vient d échapper. C est pourquoi il faut que l heuristique ait de la mémoire, le mécanisme consiste à interdire (d où le nom de tabou) certains mouvements ou certaines composantes de ce mouvement (l exemple le plus simple est d interdire les derniers mouvements). Les positions déjà explorées sont conservées dans ce qu on appel la Liste Tabou d une taille donnée, qui est un paramètre ajustable de l heuristique. pseudo code : Nous présentons un exemple de pseudo code associé à l algorithme tabou dans la figure 1 page 7 6

FIG. 1 Le pseudo code de la méthode Tabou 2.1.3 Le recuit simulé Le recuit simulé est une métaheuristique inspirée d un processus utilisé en métallurgie. Ce processus alterne des cycles de refroidissement lent et de réchauffage (recuit) qui tendent à minimiser l énergie du matériau. Elle est aujourd hui utilisée en optimisation pour trouver les extrémaux d une fonction. Elle a été mise au point par trois chercheurs de la société IBM, S. Kirkpatrick, C.D. Gelatt et M.P. Vecchi en 1983, et indépendamment par V. Cerny en 1985. pseudo code : Nous presentons la règle de Metropolis en fig 2 page 8 Déroulement du processus : Le recuit simulé s appuie sur l algorithme de Metropolis, qui permet de décrire l évolution d un système thermodynamique. Par analogie avec le processus physique, la fonction à minimiser deviendra l énergie E du système. On introduit également un paramètre fictif, la température T du système. 7

FIG. 2 La règle de décision de Metropolis Etat initial de l algorithme : La solution initiale peut être prise au hasard dans l espace des solutions possibles. A cette solution correspond une énergie initiale E = E 0. Une température initiale T = T 0 élevée est également choisie. Itérations de l algorithme : A chaque itération de l algorithme une modification élémentaire de la solution est effectuée. Cette modification entraîne une variation E de l énergie du système. Si cette variation est négative (c est-à-dire qu elle fait baisser l énergie du système), elle est appliquée à la solution courante. Sinon, elle est acceptée avec une probabilité exp( E /T ). On itère ensuite selon ce procédé en gardant la température constante. Programme de recuit : Lorsque le système a atteint un équilibre thermodynamique (au bout d un certain nombre de changements), on diminue la température du système. On parle alors de paliers de température. Si la température a atteint un seuil assez bas ou que le système devient figé, l algorithme s arrête. La température joue un rôle important. A haute température, le système est libre de se déplacer dans l espace des solutions ( exp( E /T ) proche de 1) en choisissant des solutions ne minimisant pas forcément l énergie du système. A basse température, les modifications baissant l énergie du système sont choisies, mais d autres peuvent être acceptées, empêchant ainsi l algorithme de tomber dans un 8

minimum local. pseudo code : Nous présentons le pseudo code de Méthode du Recuit Simulé dans la figure 3 page 9 FIG. 3 Le pseudo code de la méthode du recuit Simulé 2.1.4 Les voisinages Nous utiliserons deux grandes familles de voisinages pour l exploration. En effet en Sachant que lorsque la séquence est fixée nous pouvons calculer le coût optimale de la séquence, notre voisinage sera basée sur des permutations de l ordre des tâches. En tenant compte des contraintes inhérentes au calcul des séquences nous avons gardé deux grandes familles de voisinages. Le voisinage consécutif,c est à dire basé sur la permutation de deux taches consécutives et le voisinage non consécutif basée sur la permutation de deux tâches quelquonques. On verra que grâce à la structure de données utilisée pour le voisinage non consécutif on pourra utiliser des parcours pour visiter des voisinages différents. Grâce à un parcours judicieux et notre structure d arbre binaire complet pour les voisinages non 9

consécutifs,nous pourrons ainis visité le voisinage extraction insertion apr ès la position initiale et un voisinage que nous avons appelé voisinage non consécutif étendue car il contient le voisinage non consécutif et de plus il permet de le parcourir à l aide de cycles de permutations ce qui était impossible avec le voisinage non consécutif simple puisqu il n existe pas forcement de permutations permettant de passer d un voisin à l autre (dans ces voisinages on reppasse à chaque fois par la solution initiale. Nous présentons un exemple de tous les voisinages pour une séquence 1,2,3,4,5 dans le tableau 2 page 11. 10

consécutif non consécutif non consécutif etendue extraction insertion 1,0,2,3,4,5 1,0,2,3,4,5 1,0,2,3,4,5 1,0,2,3,4,5 0,2,1,3,4,5 2,1,0,3,4,5 1,2,0,3,4,5 1,2,0,3,4,5 0,1,3,2,4,5 3,1,2,0,4,5 2,1,0,3,4,5 1,2,3,0,4,5 0,1,2,4,3,5 4,1,2,3,0,5 2,1,3,0,4,5 1,2,3,4,0,5 0,1,2,3,5,4 5,1,2,3,4,0 3,1,2,0,4,5 1,2,3,4,5,0 0,2,1,3,4,5 3,1,2,4,0,5 0,2,3,4,5,1 0,3,2,1,4,5 4,1,2,3,0,5 0,2,3,4,1,5 0,4,2,3,1,5 4,1,2,3,5,0 0,2,3,1,4,5 0,5,2,3,4,1 5,1,2,3,4,0 0,2,1,3,4,5 0,1,3,2,4,5 0,1,2,3,4,5 0,1,2,3,4,5 0,1,4,3,2,5 0,2,1,3,4,5 0,1,3,2,4,5 0,1,5,3,4,2 0,2,3,1,4,5 0,1,3,4,2,5 0,1,2,4,3,5 0,3,2,1,4,5 0,1,3,4,5,2 0,1,2,5,4,3 0,3,2,4,1,5 0,1,2,4,5,3 0,1,2,3,5,4 0,4,2,3,1,5 0,1,2,4,3,5 0,4,2,3,5,1 0,1,2,3,4,5 0,5,2,3,4,1 0,1,2,3,5,4 0,1,2,3,4,5 0,1,2,3,4,5 0,1,3,2,4,5 0,1,3,4,2,5 0,1,4,3,2,5 0,1,4,3,5,2 0,1,5,3,4,2 0,1,2,3,4,5 0,1,2,4,3,5 0,1,2,4,5,3 0,1,2,5,4,3 0,1,2,3,4,5 0,1,2,3,5,4 0,1,2,3,4,5 TAB. 2 Présentation des voisinages 11

2.2 Le Sous-problème de la séquence fixée Il est possible d obtenir un ordonnancement optimal pour une séquence fixée grâce à l algorithme de programmation dynamique de Sourd.Cet algorithme calcule l ordonnancement optimal quand le séquencement est donnée pour des fonctions de coûts linéaires par morceaux. Les méthodes RS et RT sont des méthodes de voisinages. Ces voisinages sont fondées sur des modifications de séquences, comme la permutation de deux tâches, consécutives ou non. Afin de sélectionner le meilleur voisin, on peut essayer d améliorer l algorithme en évitant de repartir de zéro pour calculer le coût de toutes les séquences du voisinage. Nous appelerons cette opération calcul de voisinage. 2.2.1 Algorithme de programmation dynamique de Sourd Nous présentons les formules de l algorithme de programmation dynamique de Sourd dans le tableau 3 page 12. Conditions Σ j (t) la fonction donnant le coût minimale de l ordonnancement en respectant les conditions suivantes : la sous séquence J = {J 1,...,J j } doit être ordonnancée. J j se termine à t càd C j = t. formule de récursivité Σ j+1 (t) = min t <t p j+1 Σ j (t ) + f j+1 (t) TAB. 3 Pseudo code de l algorithme dynamique de Sourd Symétriquement on peut définir Σ j (t) comme étant le coût minimal pour ordonnancer la sous-séquence J = {J j,...,j n } de telle façon que J j se termine à t. Pour des fonctions de coût linéaires par morceaux,la complexité est proportionnelle aux nombres de segments,en effet la fonction est totalement décrite par la liste ordonnée de ces points irréguliers. 12

2.2.2 L exploration du voisinage Comme nous l avons dit précédemment les méthodes RS et RT réalise une exploration du voisinage à chacune de leurs itérations. Il faut donc concevoir des structures de données qui minimise le temps de calcul lors de cette exploration. Nous utiliserons une structure de données utilisant la propriété de symétrie de la fonction sigma dans le cas du voisinage consécutif et nous utiliserons une structure de données plus complexe un arbre binaire complet pour le voisinage non consécutif. 3 Conception des structures de données Toutes les structures de donnée ont été programmées en java.nous présentons les graphes uml associés à notre code dans les figures 4 page 15, 5 page 16, 11 page 26. 3.1 Instance du problème Toud d abord la classe representant une instance du problème : la classe Donnée. on peut initialiser cette structure aléatoirement ou avec un fichier(pour avoir le format du fichier se reporter au manuel utilisateur ).Cette sructure est une liste ordonnée d activités telles qu on les a définies auparavant. Il existe un unique objet contenant les données que tous les autres objets se partage sans jamais le modifier. 3.2 Solution Une solution au problème est donnée par une liste des dates de fins de tâches de toutes les tâches.mais pendant la résolution nous cherchons justement ses dates, nous avons donc opté pour une structure contenant la séquence des taches σ = (J 1,...,J n ) et un autre champs optionnel (en fait completer si nécessaire après la résolution du problème) qui contient les dates de fin de tâches.cette structure contient bien sur un champ pour le coût. On peut initialiser cette structure aléatoirement avec un tableau representant l ordonnancement des taches ou avec une autre solution. De plus cette classe comprends des méthodes permettant de réaliser des permutations valides ainsi que des comparaisons. 3.3 Méthodes de recherches Les Classes permettant d implémenter les algorithmes de recherche locale se trouvent dans le package Algorithme. Nous présentons les graphes uml associés à 13

ce package dans la figures 4 page 4. 3.3.1 Les recherches locales Comme nous pouvons le voir sur le Graphe UML, ce package contiens une classe appelée AbstractAlgorithme. Il s agit d une classe fortement abstraite, qui permet une normalisation des algorithmes Recuit et Simulé. Cette classe est hérité par trois autres classes abstraite : AbstractDescente, AbstractTabou et AbstractRecuit. Chacune de ces trois classes vont réunir les contraintes que leur famille d algorithmes respectives doivent respecter : (ex : liste tabou, température...).enfin chacune de ces classe sont héritées par leur version finale. Tabou, Recuit et Descente Simple, sont les classes algorithme qui vont nous permettre de répondre au problème. Remarque : Descente simple est un algorithme de Recherche Locale sans aucune stratégie particulière. Cela permet de vérifier facilement les avantages stratégique de Tabou et Recuit. 3.3.2 Les listes tabou Pour gérer les listes Tabou, une classe abstractlisttabou est nécessaire afin de s assurer qu elle possèdent toutes le même format, aussi différente soient elles ( ex : les méthodes esttabou() ou updatetabou()... ). Puis chaque type de liste Tabou hérite de abstracttabou. La liste Tabou en elle même est une liste chaînée. Cette structure est parfaitement adaptée puisque l on parcours la liste a chaque utilisation. Nous présentons les trois types de liste implémentés. Permutation Quelconque : La liste Tabou interdit que 2 taches précises soient échangées. Permutation Fixe : La liste Tabou interdit que 2 taches précises a une position précise soient échangées. Place : La liste Tabou interdit a une tache précise d aller a une position précise. 3.4 Sous-problème de la séquence fixée Le SPS étant résolu de plusieurs manières et nécessitant des classes implémentant des fonctions mathématiques a la forme d un package. Nous présentons les graphes uml associés à ce package dans la figures 5 page 5. 14

FIG. 4 Le graphe UML associé au package Algorithme. 15

16

3.4.1 Les fonctions linéaires par morceaux Le premier élement nécessaire au SPS a été une structure pour representer les fonctions de coût. Il a donc fallu créer une classe présentant certaines opérations sur l espace vectoriel des fonctions linéaires par morceaux réelles. Comme nous l avons dit précemment une liste ordonnée de segments suffit à representer une fonctions linéaires par morceaux (avec un nombre d irrégularités fini). Nous avons donc créer une première classe Domain representant un intervalle semi ouvert [a,b[. Puis nous avons représenter un segment et enfin la liste ordonnée de ces segments. Nous avons donc programmer une classe EtPiecewiseLinearMorceau possédant les propriétés et opérations de l espace vectoriel (addition multiplication par un scalaire) ainsi que certaines autres opération entre autres min t t f 1 (t ), min t t f 1 (t ), divers fonctions de décalage,min(f,g)... complexité : Soit f 1 et f 2 deux fonctions linéaire par morceaux possédant respectivement n 1 et n 2 segments. On acceptera les résultats suivants ou on se reportera au code de la classe EtPiecewiseLinearFunction : la fonction f (t) = f 1 (t) + f 2 (t) est une fonction linéaire par morceaux avec au plus n 1 + n 2 segments. Elle peut être calculée en O(n 1 + n 2 ). la fonction f (t) = min t t f 1 (t ) est une fonction linéaire par morceaux avec au plus n 1 segments. Elle peut être calculée en O(n 1 ). 3.4.2 Voisinage basée sur la permutation de deux taches consécutives Nous avons maintenant un séquencement initial σ = (J 1,...,J n ) et nous voulons calculer le coût de l ordonnancement optimal quand on permute deux tâches consécutives. Initialement, nous avons obtenu le coût minimal pour σ en appliquant l algorithme de programmation dynamique et nous avons stocké tous les résultats partiels dans un tableau avec la complexité O(n ( n i=1 f i )). Cette phase de l algorithme est appelé initialisation. Donc pour tout k < n nous voulons obtenir le coût minimale de la séquence σ k = (J 1,...,J k 1,J k+1,j k,j k+2,...,j n ). Nous allons voir que l on peut obtenir ce résultat en un temps O( n i=1 f i ). Pour cela on s intéresse d abord au coût minimale de la séquence (J 1,...,J k 1,J k+1 ) quand J k+1 se termine à t. En fonction de t ce coût est donné par : g(t) = min u t pk+1 (Σ k 1 (u)) + f k+1 (t) g(t) est linéaire par morceaux avec un nombre de segments O( f k+1 + k 1 i=1 f i ). 17

Symétriquement le coût minimal pour ordonnancer la séquence (J k,j k+2,...,j n ) quand J k se termine à t est donné par : h(t) = min v pk+2 t( Σ k+2 (v)) + f k (t) h(t) est linéaire par morceaux avec un nombre de segments O( f k + n i=k+2 f i ). Puisque la tâches J k doit commencer après la tâche J k+1,le coût minimal pour ordonnancer σ k est : min v u+pk (g(u) + h(v)) = min u (g(u) + min v u+pk h(v)) Le calcul du voisinage consiste à déterminer la meilleure séquence dans le voisinage (σ 1,...,σ n 1 ). Nous venons de voir que le coût de chaque séquence se calcule en O( n i=1 f i ). Cela prend donc O(n ( n i=1 f i )). La complexité est la même pour l initialisation. On remarque que lorsque cette algorithme est utilisée de manière itérative il faut effectuer l initialisation à chaque itération. Pour raccourcir cette phase nous n effectuerons qu une réinitialisation partielle c est à dire pour les Σ i ou i k et les Σ i ou i k. Figures : Nous présentons deux figures, la première illustrant l ensemble des fonctions Σ dans la figure 6 page 19 et le calcul d un voisin dans la figure 7 page 20. 3.4.3 Voisinage basée sur la permutation de deux taches quelquonques Nous considérons maintenant un voisinage plus large, nous voulons pouvoir permuter deux tâches quelquonques (disons J i et J j avec i < j <) dans la séquence initiale σ = (J 1,...,J n ) et obtenir le coût du nouvel ordonnancement optimal associé à la séquence σi j = (J 1,...,J j,...,j i,...,j n ). Nous allons donc avoir besoin d une structure de donnée différentes que dans la section précedente. En effet nous allons avoir besoin de connaître certaines fonctions de coût des sous séquences internes de σ. Nous désignons par : Ψ α β (t) la fonction de coût pour ordonnancer optimalement la sous-séquence allant de la αieme tâche à la βieme tâche avant la date t (i.e. avec la contrainte que la βieme tâche commence en t). Ψ α β (t) la fonction de coût pour ordonnancer optimalement la sous-séquence allant de la αieme tâche à la βieme tâche apres la date t (i.e. avec la contrainte que la αieme tâche commence en t). ˆΨ α β (t) la fonction de coût pour ordonnancer optimalement la sous-séquence allant de la αieme tâche à la βieme tâche en bloc (i.e. avec la contrainte que 18

FIG. 6 Les fonctions Σ pour une instance de 10 tâches 19

FIG. 7 calcul du coût d un voisin avec voisinage consécutif pour une instance de 10 tâches 20

toutes les tâches soit executées sans temps mort.). Ces informations sont stockés dans un arbre binaire complet,chaque noeud de l arbre represente une sous-séquence fixée. Afin d avoir un arbre binaire total,si log 2 (n) n est pas entier on rajoute des tâches fictives de coûts nulles. Nous allons maintenant donné une description de l arbre en passant par les feuilles.la Structure de l arbre est représentée en figure 8 page 21. FIG. 8 l arbre representant les sous séquences nécéssaires au calcul du voisinage non consćutif. Chaque feuille correspond à une tache, la αieme feuille en partant de la gauche correspondant à la αieme tâche de la séquence. A cette feuille sont associées les informations suivantes : J [α] est la αieme tâche de la séquence Ψ α α (t) = min u t f [α] (u) Ψ α α (t) = min u t+pα f [α] (u) ˆΨ α α (t) = f [α] (t) p α α la durée de J [α] Chaque noeud interne est indexé sous la forme α β representant la sous séquence associé à ce noeud. Chacun de ces noeuds contient les informations suivantes : 21

la sous séquence allant de la αieme tâche à la βieme tâche. Elle est formée par la concanetation de la séquence du fils gauche et celle du fils droit. Ψ α β Ψ α β ˆΨ α β p α β = β δ=α p δ On remarque que la structure de donnée décrite donne immédiatement le coût minimale de l ordonnancement associé à la séquence donné par l ordre des feuilles. Il suffit de regarder la valeur à l infini de Ψ 1 n. initialisation et mise à jour : Nous présentons dans ce paragraphe les formules permettant l initialisation et la mise à jour d un noeud lorsque le contenu de ces deux fils est connu et à jour. Ces procédures seront utilisées à la fois lors de l initialisation et lors des mises à jour consécutives à une permutation. On peut remarquer que l initialisation des feuilles est triviales. Nous allons donc presenter les formules pour les noeuds intérieurs. On commence par initialiser les feuilles. Maintenant on veut mettre à jour le noeud α β en supposant à jour son fils gauche α γ et son fils droit γ β. Tout d abord on a : p α β = p α γ + p γ+1 β ˆΨ α β = ˆΨ α γ (t p γ+1 β ) + ˆΨ γ+1 β (t) Nous allons présenter maintenant les formules de mise à jour des autres fonctions sans nous soucier de les démontrer. Soit : t αβ = min(ψ α γ + Ψ γ+1 β ) On considère que t αβ est le premier minimum atteint. On peut monter que sur l intervalle [t αβ + p γ+1 β, ] : Ψ α β (t) = Ψ γ+1 β (t) + Ψ α β ( ) Ψ γ+1 β ( ) On peut monter que sur l intervalle [0,t αβ + p γ+1 β ] Ψ α β (t) = ˆΨ γ+1 β (t) + Ψ α γ (t p γ+1 β ) La construction de Ψ α β est symétrique en renversant l echelle de temps. Nous allons maintenant présenter différentes figures illustrant les étapes présentées precedemment : Tout d abord, la figure 9 page 23 présente fonctions associées au noeud racine de l arbre binaireau et à ses 2 fils pour une instance de 10 tâches. Ensuite, la figure 10 page 24 presente les fonctions entrant en jeu dans le calcul des noeuds. 22

23 FIG. 9 présentation des fonctions associées au noeud racine de l arbre binaireau et à ses 2 fils pour une instance de 10 tâches.

24 FIG. 10 les fonctions entant en jeu dans la calcul d un parent en supposant le contenu de ses fils connus et à jour pour une instance de 10 tâches.

3.4.4 Parcours de Voisinage On remarque que contrairement à la méthode de calcul de voisinage consécutif, la structure de donnée est entièrement à jour après chaque permutation. C est cette proprièté qui nous a amener a envisager différents types de voisinages pour cette structure de donnée. En effet nous avons creer une classe de voisinage, le voisinage VNC, qui simule le comportement du voisinage VC, c est à dire qu il calcule le cout du voisin puis annule tous les changements apparus dans l arbre pour laisser la structure intacte. Dans un second temps nous avons creer deux types de voisinages qui sont des parcours, les voisinages VNCE et VEI. Ces voisinages sont constitués d un nombre fini de cycle implementé sous la forme d une liste ordonnée de permutations telle que la dernière solution trouvée soit celle dà partir de laquelle on a commencé le cycle. On parcourt alors les cycles à tour de rôle afin de parcouri le voisinage. Nous avons créer ce second type de voisinage en ésperant tirer un meilleur parti de la structure d arbre binaire et de son adaptation naturelle lors du calcul du coût d un voisin. Pour retrouver une solution il a faluu créer un système de repérage des cycles et à l intérieur des cycles afin de savoir comment atteindre n importe quelle configuration du voisinage à partir de la configuration initiale. Pour cela nous nous placons au debut du cycle contenant la configuration et nous le parcourons jusqu à la solution cherchée. 3.4.5 debugger Il existe un mode debug qui permet de tracer plus precisemment ce qui se passe lors des calculs de voisinages en réalisant des impressions des fonctions calculer,ce mode est completer par un script octave permettant de tracer un certains graphiques.on peut aussi utiliser les méthods main de certaines classes qui illustrent certaines propriétés. Pour plus de déatils on pourra se referer au manuel du programmeur. Tous les graphiques de ce document ont été produit grâce á ces méthodes. 4 Conception de l interface graphique Nous présentons les graphes uml associés à ce package dans la figures 11 page 11. Le package Ihm, comprends une classe Fenetre, qui correspond a l interface du programme. 25

26 FIG. 11 Le graphe UML associé au package Algorithme.

La Classe Courbe permet de dessiner une courbe a partir d un tableau de coordonnee dans un JPanel. La Classe LimitedDoc permet de creer un JTextField avec la contrainte de n avoir que des nombres. JTextAreaOutputStream permet de rediriger les flux de sortie System.out et System.err dans un JTextArea. 5 Analyses et tests Le package Algorithme contiens une classe nommée Test. Les méthodes de cette classe ne sont pas accessible par l interface, il faut taper la ligne : java Algorithme.Test pour pouvoir la lancer.de plus on peut se referer au manuel du programmeur pour adapter. Cette classe permet de lancer l algorithme Tabou ou/et le Recuit Simulé plusieurs fois avec une combinaison de paramètres. 5.1 Test sur le recuit Après exécution de cette classe pour le Recuit sur une instance de 20 taches, nous tombons sur quelques paramétrages intéressant notamment celui ci : Voisinage : VC Taille du palier : 100 (5* nombre de taches) Coefficient de décroissance de la température : 0.85 Température initiale : 140 Température Seuil : 30 Meilleur coût trouvé : 6223 Pire coût trouvé : 8610 Coût Moyen trouvé : 7078.35 temps d exécution moyen : 0.4 secondes Il se détache par la qualité de ses coùts trouvés et par son temps d exécution assez rapide. Bien d autre combinaisons de paramètres sont intéressantes, mais nous nous intéresseront surtout a celle ci car elle donne les meilleurs résultats sur l instance test20.txt et son temps d exécution est plutôt raisonnable. De même certains paramétrages mènent a des catastrophe comme : Voisinage : VEI Taille du palier : 10 (2* nombre de taches) Coefficient de décroissance de la température : 0.5 Température initiale : 220 Température Seuil : 130 Meilleur coût trouvé : 12063 27

Pire coût trouvé : 21423 Coût Moyen trouvé : 15742.15 temps d exécution moyen : 0.02 secondes ou encore ; Voisinage : VEI Taille du palier : 10 (2* nombre de taches) Coefficient de décroissance de la température : 0.85 Température initiale : 140 Température Seuil : 130 Meilleur coût trouvé : 13539 Pire coût trouvé : 19332 Coût Moyen trouvé : 15811.1 temps d exécution moyen : 0.02 secondes Ainsi on peut conjecturer que plus le coefficient de décroissance est petit, plus l encart entre la température seuil et initiale est élevée, plus la température initiale est élevée alors plus la qualité de la solution trouvée sera appréciable. En comparant d autres tests on remarque qu il n y a pas une grande différence pour les autre paramètres fixés entre : Température initiale : 240 ; Température Seuil : 130. Température initiale : 140 ; Température Seuil : 30. Ainsi le plus important semble être une grande variation entre la température initiale et la température seuil. Testons le meilleur paramétrage trouvé pour l instance de 50 taches test50.txt : Voisinage : VC Taille du palier : 100 (5* nombre de taches) Coefficient de décroissance de la température : 0.85 Température initiale : 140 Température Seuil : 30 Moyenne des coûts trouvé : 93457.03 Moyenne du temps d exécution : 3 secondes 5.2 Test sur le tabou Après exécution de cette classe pour le Recuit sur une instance de 20 taches et un raisonnement similaire nous pouvons conjecturer que : 1. nos listes tabous ne sont pas pertinentes, en effet elles ne semblent avoir que très peu d influence sur la qualité des solutions trouvée. (néanmoins généralement on a Tabou 3 mieux que Tabou 2 mieux que Tabou 1 ) 2. les voisinage ne semblent pas non plus très influent dans cette méthode, mais cela est sûrement du a nos listes tabous mal choisies. 28

3. Le critère d aspiration ne semble pas non plus influent sur la qualité des solutions, mais encore une fois cela peut venir du fait que nos liste tabous ne sont pas les plus appropriées. 4. pour un bon rapport temps d exécution/qualité le nombre d itération semble bien dosé pour 4*N (nombre de tache). 5. la diversification et l intensification dépendent du voisinage. Pour un voisinage VC on a de bons résultats avec intensification a 2/3 *N et la diversification a 1/2 *N ; voisinage VNC les deux critères à 1/5*N ; On n a pas pu trouver de régularité pour les autres types de voisinages. Ainsi du fait que le choix de nos listes Tabous ne semblent pas être des plus pertinent, il est assez difficile de se faire une idée sur l efficacité de la Recherche Tabou dans ce problème. Testons ces observations sur les paramètres avec l instance a 50 taches test50.txt pour un voisinage VC : Voisinage : VC Liste Tabou : Tabou 3 Itération : 200 (4* nombre de taches) Diversification : 25 Intensification : 34 Critère d aspiration : 30 Moyenne des coûts trouvé : 131465.15 Moyenne du temps d exécution : 1 seconde 5.3 Test sur la descente locale Afin de voir si les stratégies de Recherche Tabou et de Recuit Simulé sont utile dans ce problème, comparons les résultats obtenu avec une descente simple sans stratégie. Résultat de la Descente Simple avec une l instance de 50 taches test50.txt : Moyenne des coûts trouvé : 129647.24 Moyenne du temps d exécution : 1 seconde On déduit donc que La stratégie du Recuit est très significative tandis que la Recherche Tabou ne semble pas apporter de meilleurs résultats qu une descente simple. 5.4 conclusion La conclusion précedente confirme nos doutes quant à la pertinence de nos listes tabous. De plus si elles avaient un sens pour les voisinages VC et VNC, 29

elles n en ont plus pour les voisinages VNCE et VEI. En effet ces voisinages ne se trouvent pas par simple permutation mais par des combinaisons de permutation. Ainsi bloquer une permutation (la première dans les cas VNCE et VEI) n a pas réellement de sens et s en ressent dans les tests. Il pourrait être intéressant de trouver une bonne liste Tabou. Pour cela nous sommes arrivé a la conclusion qu un liste tabou doit répondre a l un des deux critères suivant (les deux étant encore mieux) : Si au cours de la résolution on tombe sur une solution S0 qui évolue en S1, alors si plus tard on a le choix entre une solution quelconque S et S0, le critère tabou doit répondre S dans la majorité des cas. Si au cours de la résolution on tombe sur une solution S0 qui évolue en S, alors si plus tard on retombe sur la solution S0, le critère tabou doit nous empêcher de choisir S1 dans la majorité des cas. De plus elle doit être suffisamment bien pensée pour ne pas stocker des quantités d informations dans la liste Tabou. C est en voulant privilégier cette dernière contrainte que nous sommes tombés dans des listes tabou peu pertinentes. à poursuivre : Nous n avons pas eu le temps de faire tourner tous les tests de notre programme et notamment les tests qui comparent les différentes méthodes initialiser avec des paramètres donnant des résultats acceptables. En effet une fois les paamètres propres à chaque méthode définis, il reste à comparer de manière statistique ces méthodes sur des instances de différentes tailles. 30

6 Références Bibliographiques Les références utilisées pour la conception du document sont : modèles et algorithmes pour l ordonnancement, groupe Gotha, Philippe Baptiste, Emmanuel Neron, Francis Sourd, Editions Ellipse, 2004 Optimisation approchée pour la recherche opérationnelle, Jacques Terghem, Marc Pirlot, Editions Hermes science, 2002 Tabu search, Fred Glover, Manuel laguna simulated annealing overview, Franco Busetti Optimal timing of a sequence of tasks with general completion costs, Francis Sourd calcul de voisinages pour l ordonnancement avec critères irréguliers, Francis Sourd, Yann Hendel, Conférence MOSIM 03, Avril 2003 La recherche tabou, Joseph Ayas, Marc-andré Viau, Novembre 2004 Le recuit simulé, Joseph Ayas, Marc-andré Viau, Novembre 2004 31