TER de maîtrise d’informatique

Compte-rendu TER 11Métaheuristique d’un

ordonnancement Juste à temps

Arnaud MalapertGildas Jeantet

Université Pierre et Marie Curie

15/06/2005

1

Table des matières

1 Présentation générale du projet 41.1 Acronymes et définitions . . . . . . . . . . . . . . . . . . . . . . 41.2 Présentation du problème . . . . . . . . . . . . . . . . . . . . . . 5

2 La Conception théorique du projet 52.1 Les Méthodes de recherche . . . . . . . . . . . . . . . . . . . . . 5

2.1.1 La recherche locale . . . . . . . . . . . . . . . . . . . . . 62.1.2 La recherche tabou . . . . . . . . . . . . . . . . . . . . . 62.1.3 Le recuit simulé . . . . . . . . . . . . . . . . . . . . . . . 72.1.4 Les voisinages . . . . . . . . . . . . . . . . . . . . . . . 9

2.2 Le Sous-problème de la séquence fixée . . . . . . . . . . . . . . . 122.2.1 Algorithme de programmation dynamique de Sourd . . . . 122.2.2 L’exploration du voisinage . . . . . . . . . . . . . . . . . 13

3 Conception des structures de données 133.1 Instance du problème . . . . . . . . . . . . . . . . . . . . . . . . 133.2 Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133.3 Méthodes de recherches . . . . . . . . . . . . . . . . . . . . . . . 13

3.3.1 Les recherches locales . . . . . . . . . . . . . . . . . . . 143.3.2 Les listes tabou . . . . . . . . . . . . . . . . . . . . . . . 14

3.4 Sous-problème de la séquence fixée . . . . . . . . . . . . . . . . 143.4.1 Les fonctions linéaires par morceaux . . . . . . . . . . . 173.4.2 Voisinage basée sur la permutation de deux taches consé-

cutives . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.4.3 Voisinage basée sur la permutation de deux taches quel-

quonques . . . . . . . . . . . . . . . . . . . . . . . . . . 183.4.4 Parcours de Voisinage . . . . . . . . . . . . . . . . . . . 253.4.5 debugger . . . . . . . . . . . . . . . . . . . . . . . . . . 25

4 Conception de l’interface graphique 25

5 Analyses et tests 275.1 Test sur le recuit . . . . . . . . . . . . . . . . . . . . . . . . . . . 275.2 Test sur le tabou . . . . . . . . . . . . . . . . . . . . . . . . . . . 285.3 Test sur la descente locale . . . . . . . . . . . . . . . . . . . . . . 295.4 conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

6 Références Bibliographiques 31

2

Table des figures

1 Pseudo code RT . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 Règle de Metropolis . . . . . . . . . . . . . . . . . . . . . . . . . 83 Pseudo code RS . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 UML Algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . 155 UML Séquence fixée . . . . . . . . . . . . . . . . . . . . . . . . 166 les fonctionsΣ . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197 calcul du coût d’un voisin . . . . . . . . . . . . . . . . . . . . . . 208 Un arbre binaire complet . . . . . . . . . . . . . . . . . . . . . . 219 root et ses fils . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2310 calcul de root . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2411 UML Algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . 26

Liste des tableaux

1 Définitions des termes . . . . . . . . . . . . . . . . . . . . . . . . 42 Les Voisinages . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 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 quel-

quonques.– 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 parcoursplusieurs cycles distincts).

– voisinage VEI: Ce voisinage a aussi une structure de parcours de cyclesmais il visite le voisinage extraction insertion avec décalage à gauche.

– cycle: une liste ordonnéec de permutations telles que∀ x l(x) = x.

Nous allons maintenant définir certains termes relatifs au problèmes dans le ta-bleau 1 page 4.

Terme Définition

J = {J1, ...,Jn} L’ensemble des tâches (jobs)n = |J| le nombre de tâches

pi la durée de la tâcheJi (processing time)r i la date de début au plus tôt de la tâcheJi (release date)di la date échue à la tâche ou écheanceJi (due date)

Si la date de début de la tâcheJi (start time)Ci la date de fin de la tâcheJi (completion time)

αi la pénalité d’avanceβi la pénalité de retard

fi(t) la déviation deJi finissant en t

TAB . 1 – La définition des termes en relation avec les données, l’ordonnancementet l’optimisation.

4

1.2 Présentation du problème

Le problème proposé présente un cas simplifié d’ordonnancement JAT : il apour 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èmed’un problème plus complexe.

La chaîne de production est ici modélisée par une seule machine (la machinecritique) qui ne peut exécuter à un moment donné qu’au plus une activité.

Les activités à exécuter sont supposées toutes connues.Un ordonnancementO = {C1, ...,Cn} est donc réalisable s’il observe les trois

contraintes suivantes :

∀i ∈ {1, ...,n} Si ≥ r i (1)

∀i ∈ {1, ...,n} pi = Ci −Si (2)

∀i ∈ {1, ...,n−1} Si+1 ≥Ci (3)

Pour chaque activitéi on a :

fi(Ci) = {max(αi × (di −Ci),βi × (Ci −di)) si Ci ≥ ri +pi

∞ si Ci < ri +pi

Le but du problème est de trouver un ordonnancement réalisable minimisantla pénalité totale :

coutO =n

∑i=1

fi(Ci)

existence d’un ordonnancement de coût nul : d’après nos hypothèses, le coûtde chaque tâche est positif ou nul. Donc, s’il existe un ordonnancement de coûtnul chaque tâche a un coût nul, ce qui signifie qu’elle termine à sa date d’échéancesi aucune des pénalités n’est nulle. Bien qu on puisse Verifier à la main s’il existeun ordonnancement de cout nul avec des pénalités nulles,nous considérerons quepuisque cette étape peut faire intervenir une permutation de l’ordre des tâches,elledoit être trouvée par nos méthodes de recherche. On peut donc verifier si l’ordon-nancement :∀i ∈ {1, ...,N}, Cj = d j est réalisable.Cette opération peut se réaliserenO(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, parcou-rir 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 versles algorithmes de Recherche Locale.

2.1.1 La recherche locale

Cette famille d’algorithme ne permet pas de trouver la meilleure solution (ousi elle est trouvée ne permet pas de le prouver), mais permet de trouver une bonnesolution en un temps plus raisonnable.

2.1.2 La recherche tabou

La recherche tabou est une métaheuristique d’optimisation présentée par FredGlover en 1986. On trouve souvent l’appellationrecherche avec tabousen 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 minimisela 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 voisinageont une valeur plus élevée. C’est à partir de ce mécanisme que l’on échappe auxminima locaux. Le risque cependant est qu’à l’étape suivante, on retombe dans leminimum local auquel on vient d’échapper. C’est pourquoi il faut que l’heuris-tique 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 leplus simple est d’interdire les derniers mouvements). Les positions déjà exploréessont conservées dans ce qu’on appel la Liste Tabou d’une taille donnée, qui est unparamètre ajustable de l’heuristique.

pseudo code : Nous présentons un exemple de pseudo code associé à l’algo-rithme 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 utili-sée en optimisation pour trouver les extrémaux d’une fonction. Elle a été mise aupoint 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 Me-tropolis, qui permet de décrire l’évolution d’un système thermodynamique. Paranalogie avec le processus physique, la fonction à minimiser deviendra l’énergieE du système. On introduit également un paramètre fictif, la température T dusystème.

7

FIG. 2 – La règle de décision de Metropolis

Etat initial de l’algorithme : La solution initiale peut être prise au hasarddans l’espace des solutions possibles. A cette solution correspond une énergieinitiale E = E0. Une température initialeT = T0 élevée est également choisie.

Itérations de l’algorithme : A chaque itération de l’algorithme une modi-fication élémentaire de la solution est effectuée. Cette modification entraîne unevariation∆E de l’énergie du système. Si cette variation est négative (c’est-à-direqu’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 selonce procédé en gardant la température constante.

Programme de recuit : Lorsque le système a atteint un équilibre thermo-dynamique (au bout d’un certain nombre de changements), on diminue la tem-pérature du système. On parle alors de paliers de température. Si la températurea 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 librede se déplacer dans l’espace des solutions ( exp(−∆E/T) proche de 1) en choi-sissant des solutions ne minimisant pas forcément l’énergie du système. A bassetempérature, les modifications baissant l’énergie du système sont choisies, maisd’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. Eneffet en Sachant que lorsque la séquence est fixée nous pouvons calculer le coûtoptimale de la séquence, notre voisinage sera basée sur des permutations de l’ordredes tâches. En tenant compte des contraintes inhérentes au calcul des séquencesnous avons gardé deux grandes familles de voisinages. Le voisinage consécu-tif,c’est à dire basé sur la permutation de deux taches consécutives et le voisinagenon consécutif basée sur la permutation de deux tâches quelquonques. On verraque grâce à la structure de données utilisée pour le voisinage non consécutif onpourra utiliser des parcours pour visiter des voisinages différents. Grâce à un par-cours 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 laposition 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 par-courir à l’aide de cycles de permutations ce qui était impossible avec le voisinagenon consécutif simple puisqu’il n’existe pas forcement de permutations permet-tant de passer d’un voisin à l’autre (dans ces voisinages on reppasse à chaque foispar la solution initiale.

Nous présentons un exemple de tous les voisinages pour une séquence 1,2,3,4,5dans le tableau 2 page 11.

10

consécutif non consécutif non consécutif etendue extraction insertion1,0,2,3,4,5 1,0,2,3,4,5 1,0,2,3,4,5 1,0,2,3,4,50,2,1,3,4,5 2,1,0,3,4,5 1,2,0,3,4,5 1,2,0,3,4,50,1,3,2,4,5 3,1,2,0,4,5 2,1,0,3,4,5 1,2,3,0,4,50,1,2,4,3,5 4,1,2,3,0,5 2,1,3,0,4,5 1,2,3,4,0,50,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,10,3,2,1,4,5 4,1,2,3,0,5 0,2,3,4,1,50,4,2,3,1,5 4,1,2,3,5,0 0,2,3,1,4,50,5,2,3,4,1 5,1,2,3,4,0 0,2,1,3,4,50,1,3,2,4,5 0,1,2,3,4,5 0,1,2,3,4,50,1,4,3,2,5 0,2,1,3,4,5 0,1,3,2,4,50,1,5,3,4,2 0,2,3,1,4,5 0,1,3,4,2,50,1,2,4,3,5 0,3,2,1,4,5 0,1,3,4,5,20,1,2,5,4,3 0,3,2,4,1,5 0,1,2,4,5,30,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,50,5,2,3,4,1 0,1,2,3,5,40,1,2,3,4,5 0,1,2,3,4,50,1,3,2,4,50,1,3,4,2,50,1,4,3,2,50,1,4,3,5,20,1,5,3,4,20,1,2,3,4,50,1,2,4,3,50,1,2,4,5,30,1,2,5,4,30,1,2,3,4,50,1,2,3,5,40,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éegrâce à l’algorithme de programmation dynamique de Sourd.Cet algorithme cal-cule l’ordonnancement optimal quand le séquencement est donnée pour des fonc-tions de coûts linéaires par morceaux.

Les méthodes RS et RT sont des méthodes de voisinages. Ces voisinagessont fondées sur des modifications de séquences, comme la permutation de deuxtâches, consécutives ou non. Afin de sélectionner le meilleur voisin, on peut es-sayer d’améliorer l’algorithme en évitant de repartir de zéro pour calculer le coûtde toutes les séquences du voisinage. Nous appelerons cette opération“calcul devoisinage”.

2.2.1 Algorithme de programmation dynamique de Sourd

Nous présentons les formules de l’algorithme de programmation dynamiquede Sourd dans le tableau 3 page 12.

Conditions

Σ j(t) la fonction donnant le coût minimale de l’ordonnancementen respectant les conditions suivantes :

la sous séquenceJ = {J1, ...,Jj} doit être ordonnancée.Jj se termine àt càdCj = t.

formule de récursivité

Σ j+1(t) = mint ′<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 or-donnancer la sous-séquenceJ = {Jj , ...,Jn} de telle façon queJj se termine àt.

Pour des fonctions de coût linéaires par morceaux,la complexité est propor-tionnelle aux nombres de segments,en effet la fonction est totalement décrite parla 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 uneexploration du voisinage à chacune de leurs itérations. Il faut donc concevoir desstructures 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étriede la fonction sigma dans le cas du voisinage consécutif et nous utiliserons unestructure de données plus complexe un arbre binaire complet pour le voisinagenon consécutif.

3 Conception des structures de données

Toutes les structures de donnée ont été programmées en java.Nous présentonsles graphes uml associés à notre code dans les figures 4 page 15 , 5 page 16 , 11page 26.

3.1 Instance du problème

Toud d’abord la classe representant une instance du problème : la classe Don-née. on peut initialiser cette structure aléatoirement ou avec un fichier(pour avoirle format du fichier se reporter au manuel utilisateur ).Cette sructure est une listeordonnée d’activités telles qu’on les a définies auparavant. Il existe un uniqueobjet contenant les données que tous les autres objets se partage sans jamais lemodifier.

3.2 Solution

Une solution au problème est donnée par une liste des dates de fins de tâchesde toutes les tâches.Mais pendant la résolution nous cherchons justement sesdates, nous avons donc opté pour une structure contenant la séquence des tachesσ = (J1, ...,Jn) et un autre champs optionnel (en fait completer si nécessaire aprèsla résolution du problème) qui contient les dates de fin de tâches.Cette structurecontient bien sur un champ pour le coût. On peut initialiser cette structure aléa-toirement avec un tableau representant l’ordonnancement des taches ou avec uneautre solution. De plus cette classe comprends des méthodes permettant de réaliserdes permutations valides ainsi que des comparaisons.

3.3 Méthodes de recherches

Les Classes permettant d’implémenter les algorithmes de recherche locale setrouvent 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 uneclasse appelée AbstractAlgorithme. Il s’agit d’une classe fortement abstraite, quipermet une normalisation des algorithmes Recuit et Simulé. Cette classe est héritépar trois autres classes abstraite : AbstractDescente, AbstractTabou et Abstrac-tRecuit. Chacune de ces trois classes vont réunir les contraintes que leur familled’algorithmes respectives doivent respecter : (ex : liste tabou, température ...).En-fin chacune de ces classe sont héritées par leur version finale. Tabou, Recuit etDescente Simple, sont les classes algorithme qui vont nous permettre de répondreau problème.

Remarque : Descente simple est un algorithme de Recherche Locale sans au-cune stratégie particulière. Cela permet de vérifier facilement les avantages stra-tégique de Tabou et Recuit.

3.3.2 Les listes tabou

Pour gérer les listes Tabou, une classe abstractListTabou est nécessaire afinde 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 listeTabou 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 chaqueutilisation. Nous présentons les trois types de liste implémentés.

– Permutation Quelconque: La liste Tabou interdit que 2 taches précisessoient échangées.

– Permutation Fixe: La liste Tabou interdit que 2 taches précises a une posi-tion précise soient échangées.

– Place : La liste Tabou interdit a une tache précise d’aller a une positionpré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ésentonsles graphes uml associés à ce package dans la figures 5 page 5 .

14

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

15

FIG. 5 – Le graphe UML associé au package SequenceFixee.

16

3.4.1 Les fonctions linéaires par morceaux

Le premier élement nécessaire au SPS a été une structure pour representer lesfonctions de coût. Il a donc fallu créer une classe présentant certaines opérationssur l’espace vectoriel des fonctions linéaires par morceaux réelles. Comme nousl’avons dit précemment une liste ordonnée de segments suffit à representer unefonctions linéaires par morceaux (avec un nombre d’irrégularités fini).

Nous avons donc créer une première classe Domain representant un intervallesemi ouvert [a,b[. Puis nous avons représenter un segment et enfin la liste ordon-né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 multiplicationpar un scalaire) ainsi que certaines autres opération entre autresmint ′≤t f1(t ′),mint ′≥t f1(t ′), divers fonctions de décalage,min(f,g)...

complexité : Soit f1 et f2 deux fonctions linéaire par morceaux possédant res-pectivementn1 etn2 segments. On acceptera les résultats suivants ou on se repor-tera au code de la classe EtPiecewiseLinearFunction :

– la fonction f (t) = f1(t)+ f2(t) est une fonction linéaire par morceaux avecau plusn1 +n2 segments. Elle peut être calculée enO(n1 +n2).

– la fonction f (t) = mint ′≤t f1(t ′) est une fonction linéaire par morceaux avecau plusn1 segments. Elle peut être calculée enO(n1).

3.4.2 Voisinage basée sur la permutation de deux taches consécutives

Nous avons maintenant un séquencement initialσ = (J1, ...,Jn) et nous vou-lons calculer le coût de l’ordonnancement optimal quand on permute deux tâchesconsécutives.

Initialement, nous avons obtenu le coût minimal pourσ en appliquant l’al-gorithme de programmation dynamique et nous avons stocké tous les résultatspartiels dans un tableau avec la complexitéO(n× (∑n

i=1‖ fi‖)). Cette phase del’algorithme est appelé initialisation.

Donc pour toutk < n nous voulons obtenir le coût minimale de la séquenceσk = (J1, ...,Jk−1,Jk+1,Jk,Jk+2, ...,Jn). Nous allons voir que l’on peut obtenir cerésultat en un tempsO(∑n

i=1‖ fi‖).Pour cela on s’intéresse d’abord au coût minimale de la séquence(J1, ...,Jk−1,Jk+1)

quandJk+1 se termine à t. En fonction de t ce coût est donné par :

g(t) = minu≤t−pk+1(Σk−1(u))+ fk+1(t)

g(t) est linéaire par morceaux avec un nombre de segmentsO(‖ fk+1‖+∑k−1i=1 ‖ fi‖).

17

Symétriquement le coût minimal pour ordonnancer la séquence(Jk,Jk+2, ...,Jn)quandJk se termine à t est donné par :

h(t) = minv−pk+2≥t(Σk+2(v))+ fk(t)

h(t) est linéaire par morceaux avec un nombre de segmentsO(‖ fk‖+∑ni=k+2‖ fi‖).

Puisque la tâchesJk doit commencer après la tâcheJk+1,le coût minimal pourordonnancerσk est :

minv≥u+pk(g(u)+h(v)) = minu(g(u)+minv≥u+pkh(v))

Le calcul du voisinage consiste à déterminer la meilleure séquence dans levoisinage(σ1, ...,σn−1). Nous venons de voir que le coût de chaque séquence secalcule enO(∑n

i=1‖ fi‖). Cela prend doncO(n× (∑ni=1‖ fi‖)) . La complexité est

la même pour l’initialisation .

On remarque que lorsque cette algorithme est utilisée de manière itérative ilfaut effectuer l’initialisation à chaque itération. Pour raccourcir cette phase nousn’effectuerons qu’une réinitialisation partielle c’est à dire pour lesΣi ou i ≥ k etlesΣi ou i ≤ k.

Figures : Nous présentons deux figures, la première illustrant l’ensemble desfonctionsΣ dans la figure 6 page 19 et le calcul d’un voisin dans la figure 7 page20.

3.4.3 Voisinage basée sur la permutation de deux taches quelquonques

Nous considérons maintenant un voisinage plus large, nous voulons pouvoirpermuter deux tâches quelquonques (disonsJi etJj aveci < j <) dans la séquenceinitiale σ = (J1, ...,Jn) et obtenir le coût du nouvel ordonnancement optimal asso-cié à la séquenceσi j = (J1, ...,Jj , ...,Ji , ...,Jn).

Nous allons donc avoir besoin d’une structure de donnée différentes que dansla section précedente. En effet nous allons avoir besoin de connaître certainesfonctions 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équenceallant de laαiemetâche à laβiemetâche avant la date t (i.e. avec la contrainteque laβiemetâche commence en t).

– Ψα→β(t) la fonction de coût pour ordonnancer optimalement la sous-séquenceallant de laαiemetâche à laβiemetâche apres la date t (i.e. avec la contrainteque laαiemetâche commence en t).

– Ψα→β(t) la fonction de coût pour ordonnancer optimalement la sous-séquenceallant de laαiemetâche à laβiemetâ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 instancede 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 del’arbre represente une sous-séquence fixée. Afin d’avoir un arbre binaire total,silog2(n) n’est pas entier on rajoute des tâches fictives de coûts nulles. Nous al-lons maintenant donné une description de l’arbre en passant par les feuilles.LaStructure 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 voisinagenon conscutif.

Chaque feuille correspond à une tache, laαiemefeuille en partant de la gauchecorrespondant à laαiemetâche de la séquence. A cette feuille sont associées lesinformations suivantes :

– J[α] est laαiemetâche de la séquence– Ψα→α(t) = minu≤t f[α](u)– Ψα→α(t) = minu≥t+pα f[α](u)– Ψα→α(t) = f[α](t)– pα→α la durée deJ[α]

Chaque noeud interne est indexé sous la formeα → β representant la sousséquence associé à ce noeud. Chacun de ces noeuds contient les informationssuivantes :

21

– la sous séquence allant de laαiemetâche à laβiemetâche. Elle est forméepar 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ûtminimale 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 formulespermettant l’initialisation et la mise à jour d’un noeud lorsque le contenu de cesdeux fils est connu et à jour. Ces procédures seront utilisées à la fois lors de l’ini-tialisation et lors des mises à jour consécutives à une permutation. On peut remar-quer que l’initialisation des feuilles est triviales. Nous allons donc presenter lesformules pour les noeuds intérieurs.

On commence par initialiser les feuilles. Maintenant on veut mettre à jour lenoeudα → β 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 fonc-tions sans nous soucier de les démontrer. Soit :

tαβ = min(Ψα→γ + Ψγ+1→β)

On considère quetαβ 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

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

23

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

24

3.4.4 Parcours de Voisinage

On remarque que contrairement à la méthode de calcul de voisinage consécu-tif, la structure de donnée est entièrement à jour après chaque permutation. C’estcette proprièté qui nous a amener a envisager différents types de voisinages pourcette structure de donnée.

En effet nous avons creer une classe de voisinage, le voisinage VNC, qui si-mule le comportement du voisinage VC, c’est à dire qu’il calcule le cout du voisinpuis annule tous les changements apparus dans l’arbre pour laisser la structure in-tacte.

Dans un second temps nous avons creer deux types de voisinages qui sontdes parcours, les voisinages VNCE et VEI. Ces voisinages sont constitués d’unnombre fini de cycle implementé sous la forme d’une liste ordonnée de permu-tations telle que la dernière solution trouvée soit celle dà partir de laquelle on acommencé le cycle. On parcourt alors les cycles à tour de rôle afin de parcouri levoisinage.

Nous avons créer ce second type de voisinage en ésperant tirer un meilleurparti de la structure d’arbre binaire et de son adaptation naturelle lors du calculdu coût d’un voisin. Pour retrouver une solution il a faluu créer un système derepérage des cycles et à l’intérieur des cycles afin de savoir comment atteindren’importe quelle configuration du voisinage à partir de la configuration initiale.Pour cela nous nous placons au debut du cycle contenant la configuration et nousle parcourons jusqu’à la solution cherchée.

3.4.5 debugger

Il existe un mode debug qui permet de tracer plus precisemment ce qui sepasse lors des calculs de voisinages en réalisant des impressions des fonctionscalculer,ce mode est completer par un script octave permettant de tracer un cer-tains graphiques.On peut aussi utiliser les méthods main de certaines classes quiillustrent certaines propriétés. Pour plus de déatils on pourra se referer au manueldu programmeur. Tous les graphiques de ce document ont été produit grâce á cesméthodes.

4 Conception de l’interface graphique

Nous présentons les graphes uml associés à ce package dans la figures 11 page11.

Le package Ihm, comprends une classe Fenetre, qui correspond a l’interfacedu programme.

25

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

26

La Classe Courbe permet de dessiner une courbe a partir d’un tableau de co-ordonnee dans un JPanel.

La Classe LimitedDoc permet de creer un JTextField avec la contrainte den’avoir que des nombres.

JTextAreaOutputStream permet de rediriger les flux de sortie System.out etSystem.err dans un JTextArea.

5 Analyses et tests

Le package Algorithme contiens une classe nommée Test. Les méthodes decette classe ne sont pas accessible par l’interface, il faut taper la ligne : ’javaAlgorithme.Test’ pour pouvoir la lancer.De plus on peut se referer au manuel duprogrammeur pour adapter.

Cette classe permet de lancer l’algorithme Tabou ou/et le Recuit Simulé plu-sieurs 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écutionassez rapide. Bien d’autre combinaisons de paramètres sont intéressantes, maisnous nous intéresseront surtout a celle ci car elle donne les meilleurs résultats surl’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 secondesAinsi 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 initialeest élevée alors plus la qualité de la solution trouvée sera appréciable. En compa-rant d’autres tests on remarque qu’il n’y a pas une grande différence pour les autreparamè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 ini-tiale 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 etun raisonnement similaire nous pouvons conjecturer que :

1. nos listes tabous ne sont pas pertinentes, en effet elles ne semblent avoirque très peu d’influence sur la qualité des solutions trouvée. (néanmoinsgé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é dessolutions, mais encore une fois cela peut venir du fait que nos liste tabousne sont pas les plus appropriées.

4. pour un bon rapport temps d’exécution/qualité le nombre d’itération semblebien dosé pour 4*N (nombre de tache).

5. la diversification et l’intensification dépendent du voisinage. Pour un voisi-nage VC on a de bons résultats avec intensification a 2/3 *N et la diversifi-cation a 1/2 *N ; voisinage VNC les deux critères à 1/5*N ; On n’a pas putrouver de régularité pour les autres types de voisinages.

Ainsi du fait que le choix de nos listes Tabous ne semblent pas être des pluspertinent, il est assez difficile de se faire une idée sur l’efficacité de la RechercheTabou 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 utiledans ce problème, comparons les résultats obtenu avec une descente simple sansstraté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 secondeOn 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 descentesimple.

5.4 conclusion

La conclusion précedente confirme nos doutes quant à la pertinence de noslistes 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 nese 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 pasréellement de sens et s’en ressent dans les tests.

Il pourrait être intéressant de trouver une bonne liste Tabou. Pour cela noussommes arrivé a la conclusion qu’un liste tabou doit répondre a l’un des deuxcritè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, lecritè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 nousempêcher de choisir S1 dans la majorité des cas.

De plus elle doit être suffisamment bien pensée pour ne pas stocker des quan-tités d’informations dans la liste Tabou. C’est en voulant privilégier cette dernièrecontrainte 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 denotre programme et notamment les tests qui comparent les différentes méthodesinitialiser avec des paramètres donnant des résultats acceptables. En effet une foisles paamètres propres à chaque méthode définis, il reste à comparer de manièrestatistique 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, PhilippeBaptiste, Emmanuel Neron, Francis Sourd, Editions Ellipse, 2004

– “Optimisation approchée pour la recherche opérationnelle”, Jacques Ter-ghem, 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