Julien MELLANO Arnaud THIRY

LES ALGORITHMES GENETIQUES MULTICRITERES POUR L’ORDONNANCEMENT DU JOB SHOP

Projet proposé par M. Youssef HARRATH Optimisation Combinatoire INSA de Rouen – 2004

2

3

SOMMAIRE

1 INTRODUCTION................................................................................................... 5 2 Notions générales d’ordonnancement ................................................................... 6

2.1 Les éléments d’un problème d’ordonnancement............................................ 6 2.1.1 Les tâches............................................................................................... 6 2.1.2 Les ressources........................................................................................ 6 2.1.3 Les contraintes........................................................................................ 6 2.1.4 Les objectifs d’optimisation ..................................................................... 7

2.2 Les types d’ordonnancements : ..................................................................... 7

2.2.1 Flow shop................................................................................................ 7 2.2.2 Job shop ................................................................................................. 8 2.2.3 Open shop............................................................................................... 8

2.3 Modélisation et représentation des ordonnancements ................................... 8

2.4 Classification des ordonnancements............................................................. 9

2.4.1 Ordonnancement admissible................................................................... 9 2.4.2 Ordonnancement semi actif (procédure Gantt) ....................................... 9 2.4.3 Ordonnancement actif ........................................................................... 10 2.4.4 Ordonnancement sans retard (procédure améliorer) ............................ 10

3 L’ordonnancement du Job shop .......................................................................... 11

3.1 Formalisation du job shop ............................................................................ 11 3.2 Contraintes et objectifs................................................................................. 11 3.3 Représentation graphique du job shop......................................................... 12

4 Les algorithmes génétiques................................................................................. 13

4.1 Principe des algorithmes génétiques............................................................ 13 4.2 La notion d’algorithme génétique multicritères ............................................. 14

5 La résolution d’un problème de job shop par les algorithmes génétiques multicritères. ............................................................................................................... 15

5.1 L’exemple traité ............................................................................................ 15 5.1.1 Le codage des chromosomes ............................................................... 15 5.1.2 Description de l’algorithme.................................................................... 16 5.1.3 Génération d’une population de chromosomes (réparation de chromosome) ...................................................................................................... 16 5.1.4 Opérateurs de mutation et de croisement ............................................. 17 5.1.5 Evaluation et sélection du chromosome................................................ 18 5.1.6 Faisabilité du chromosome (procédure Gantt) ...................................... 18 5.1.7 Amélioration du chromosome (ordonnancement sans retard)............... 21

4

6 Déroulement du programme................................................................................ 22 6.1 Choix du problème ....................................................................................... 22 6.2 Choix du mode de sélection ......................................................................... 23 6.3 Premier chromosome généré....................................................................... 23 6.4 Résultats ...................................................................................................... 25

7 Déroulement du projet ......................................................................................... 26

7.1 Documentation ............................................................................................. 26 7.2 Programmation............................................................................................. 26

7.2.1 Codage ................................................................................................. 26 7.2.2 Génération de la population .................................................................. 26 7.2.3 GANTT & réparation ............................................................................. 26

7.3 Evolution des résultats ................................................................................. 27

7.3.1 Premier résultat sur le problème 6*6..................................................... 27 7.3.2 Réunion du 15 avril 04 : ........................................................................ 27 7.3.3 Ameliorer............................................................................................... 27 7.3.4 Résultats obtenus : ............................................................................... 27 7.3.5 Réunion du 6 mai 04 : ........................................................................... 28 7.3.6 PARETO ............................................................................................... 28 7.3.7 Générer Problème................................................................................. 28

7.4 Les derniers résultats obtenus ..................................................................... 28 7.5 Plan de charges ........................................................................................... 29 7.6 Améliorations possibles................................................................................ 29

8 Conclusion........................................................................................................... 30

5

1 INTRODUCTION Sujet : Le travail consiste à étudier les algorithmes génétiques multicritères pouvant être adaptés à la résolution du Job shop. Plusieurs types de sélection seront ainsi implantés et comparées afin de garder la meilleure. L’implantation se fera à l’aide de la programmation en C. On utilisera pour les tests expérimentaux une génération aléatoire de problèmes de job shop de différentes tailles. Les critères d’optimisation étudiés sont le makespan : Cmax (date d’achèvement de l’ordonnancement) et le flot total. Nous commencerons par rappeler les différentes définitions des notions d’ordonnancement, de job shop et des algorithmes génétiques. Nous expliquerons ensuite l’intérêt de ces algorithmes pour un problème d’ordonnancement. Enfin nous introduirons la notion d’algorithme génétique multicritères (multiobjectifs). Nous illustrerons cet exposé par la programmation d’un algorithme génétique permettant d’obtenir une bonne solution pour un ordonnancement de job-shop de tailles6*6 (6 jobs de 6 opérations élémentaire réalisé sur six machines différentes). Le programme donne aussi la possibilité de générer des problèmes de job shop 6*6 de manière aléatoire. Nous aurions pu créer des jobs shop de tailles plus importantes mais les choix de programmation pris au début du projet ont fait que nous n’en avons malheureusement pas eu le temps.

6

2 Notions générales d’ordonnancement Définition : l’ordonnancement consiste à organiser dans le temps la réalisation d’un ensemble de tâches, compte tenu de contraintes temporelles (délais, contraintes d’enchaînement, etc.) et de contraintes portant sur l’utilisation et la disponibilité des ressources requises par les tâches. Un ordonnancement décrit l’ordre d’exécution des tâches et l’allocation des ressources au cours du temps, afin de satisfaire un ou plusieurs critères d’optimisation.

2.1 Les éléments d’un problème d’ordonnancement

2.1.1 Les tâches Ce sont toutes les opérations élémentaires du travail pour la fabrication d’un produit. Une tâche i est généralement caractérisée par une date de début si, une date de fin ci (completion time) et une durée d’exécution pi. Certaines contraintes techniques ou économiques peuvent associées aux tâches des dates de début au plus tôt ri ready time) ou des dates de fin au plus tard di (due date). Une tâche peut se réaliser par morceaux ; il s’agit alors de tâche préemptive, ou sans interruption et on parle alors de tâche non-préemptive. Dans certains cas, les tâches peuvent présenter des priorités d’exécutions dues aux clients, on leur attribue un poids wi proportionnels à leur degré de priorité.

2.1.2 Les ressources L’exécution des différentes tâches nécessite la mise en œuvre d’un ensemble de moyens techniques et d’opérateurs humains. Cet ensemble représente donc les ressources indispensables à la réalisation des tâches durant des intervalles de disponibilités. La capacité d’une ressource est en réalité limitée. Ce dont ne nous avons pas tenu compte dans l’exemple que nous avons traité. Dans notre exemple les ressources utilisées sont des machines c’est-à-dire des ressources renouvelables et disjonctives (elles ne peuvent réalisées qu’une opération à la fois).

2.1.3 Les contraintes Les contraintes expriment des restrictions sur les valeurs que peuvent avoir les variables de décision. Leur prise en compte permet d’avoir un ordonnancement réalisable. Les contraintes sont soit de type classique (temporelle et liée aux ressources) soit endogènes, c’est-à-dire directement liée au système de production et à ses performances. Dans notre cas nous ne nous intéresserons qu’aux contraintes temporelles :

• les contraintes temporelles : souvent, les opérations ne peuvent s’exécuter qu’après une date de début au plus tôt, c’est-à-dire satisfaisant l’expression suivante : ci - pi ≥ ri et ne finissent qu’avant une date de fin au plus tard, ce qui revient à vérifier la formule suivante : ri+pi ≤ di . Ceci reflète la non-disponibilité continue des ressources (pour les dates au plus tôt) et la nécessité de délivrer de produits en respectant des délais (date au plus tard). Ce type de contraintes permet aussi de définir les relations de précédence entre les opérations (par exemple : perçage d’un trou puis insertion d’une vis.). En fait ce sont les contraintes technologiques qui imposent un ordre d’exécution aux opérations. La relation de précédence entre deux tâches i et j s’écrit : si + pi ≤ sj.

2.1.4 Les objectifs d’optimisation Lorsqu’on aborde un problème d’ordonnancement, on cherche en général à optimiser (minimiser ou maximiser) une fonction d’évaluation en respectant un certain nombres de contraintes. Le credo des ateliers reste le triptyque coût/qualité/délais. Toute évaluation d’un ordonnancement n’a donc de sens que si elle porte sur ces trois facettes. Dans notre exemple nous ne nous intéresserons qu’à l’aspect délai puisque les critères que nous cherchons à optimiser sont des critères temporels. En effet, nous utiliserons dans la liste ci-dessous uniquement le Cmax et le flot total.

2.2 Les types d’ordonnancements : Soit un atelier de m stations différentes. Chaque station comporte une ou plusieurs machines en parallèle. Les travaux à réaliser sont constitués d’un ensemble de n opérations élémentaires. Chacune d’elle doit s’exécuter sur une machine différente de celles des autres opérations. En fonction du mode de passage des opérations sur les machines (appelé aussi gamme opératoire), trois classes d’ateliers sont distinguées, à savoir le flow shop, le job shop et le open shop.

2.2.1 Flow shop Le flow shop se rencontre dans les ateliers disposant de lignes de production dédiées à la production de masse de peu de variété de produit. Un tel atelier est aussi appelé atelier en ligne ou à cheminement unique où toutes les gammes sont identiques. Chaque job est constitué de m opérations (où m est le nombre de machine). Chacune de ces opérations doit être exécutée sur une machine différente. L’ordre de passage des opérations sur les machines est le même pour tous les jobs.

7

2.2.2 Job shop Dans cette classe d’atelier, chaque tâche possède son propre mode de passage sur les machines. A titre d’exemple, considérons le problème de teinture de tissus. Suivant le type de tissu et la couleur désirée, l’ordre de passage dans les différents bains ne sera pas le même. Le job shop est notre cas d’étude, nous le détaillerons plus tard dans ce rapport.

2.2.3 Open shop Dans un atelier open shop, le cheminement des jobs est multiple, mais à la différence du job shop, les jobs ne possèdent pas de gamme. L’ordre de passage des opérations est ainsi quelconque (atelier à cheminement libre). Ce paramètre est déterminé lors de l’ordonnancement.

2.3 Modélisation et représentation des ordonnancements Un graphe de précédence est constitué d’un ensemble de noeuds et de deux types d’arcs. Les nœuds représentent les tâches à réaliser. Les arcs conjonctifs valués de la durée de réalisation de la tâche d’où l’arc sort, représentent les contraintes de précédence. Les arcs disjonctifs à deux sens représentent les contraintes des ressources. Pour représenter le début et la fin de l’ordonnancement, deux nœuds fictifs sont rajoutés aux graphes.

Le diagramme de Gantt est certainement le type de représentation le plus simple pour visualiser graphiquement l’exécution des tâches et/ou l’occupation des ressources au cours du temps. Il consiste à placer les tâches en ordonnées sur un tableau où le temps est en abscisse et les ressources en ordonnées. A chaque tâche est associé un segment, ou barre, horizontal de longueur proportionnelle à la durée de traitement. Nous nous sommes beaucoup appuyé sur ce type de représentation pour obtenir nos résultats. (Voir exemple dans la partie suivante).

8

2.4 Classification des ordonnancements Définition : Un critère est dit régulier si sa performance ne se dégrade pas en avançant l’exécution de la tâche. Les classes d’ordonnancement présentent des propriétés de dominance vis-à-vis de tout critère régulier. Voici les différentes classes d’ordonnancement :

2.4.1 Ordonnancement admissible Un ordonnancement est admissible si l’ordre d’affectation de ces tâches respecte les contraintes du problème. (Voir exemple). Cet ordonnancement respecte les contraintes de précédence entre les différentes tâches ainsi que la capacité maximale de la machine à tout instant t.

Dans l’exemple, la valeur du critère d’optimisation de l’ordonnancement est égale à 11

2.4.2 Ordonnancement semi actif (procédure Gantt) Il est possible d’améliorer les performances d’un ordonnancement admissible pour un critère régulier tel que le makespan. Il s’agit de réaliser des décalages à gauche de certaines tâches pour combler des vides à condition de ne pas violées les contraintes imposées par le problème (telles que les dates de début au plus tôt). Si aucun décalage à gauche n’est possible, c’est-à-dire qu’on ne peut plus avancer une tâche sans modifier la séquence initiale, alors l’ordonnancement obtenu est semi actif.

Pour l’exemple, un décalage d’une unité des tâches e et d permet d’avoir un ordonnancement semi actif avec un Cmax amélioré d’une unité (10).

9

2.4.3 Ordonnancement actif Un ordonnancement est actif si aucun décalage ou permutation de ces tâches n’est possible. Aucune tâche ne peut commencer plus tôt sans reporter le début d’une autre.

Par exemple une permutation des tâches e et d dans l’exemple de l’ordonnancement semi actif, permet d’avoir un ordonnancement actif optimisant le Cmax (9).

2.4.4 Ordonnancement sans retard (procédure améliorer) Pour obtenir un ordonnancement sans retard, il suffit d’affecter les tâches vérifiant les contraintes du problème sur les machines disponibles sans retard. Ceci vaut dire que dès qu’une source est libre et qu’il existe une tâche en attente, alors il faut l’affecter sans aucun retard. Notons qu’un ordonnancement sans retard n’est pas forcément optimal.

L’exemple suivant montre un ordonnancement sans retard avec un Cmax de 11.

Caractérisation des solutions En général, on situe la solution optimum d’un problème dans un ensemble d’ordonnancement actif et/ou sans retard. Ce résultat est obtenu en comparant les ensembles d’ordonnancements. La solution doit se trouver dans le plus petit espace dominant pour un critère régulier, cet ensemble est l’ensemble des ordonnancements actifs. Nous y ajoutons la possibilité d’avoir des solutions sans retards qui sont en général de bonnes solutions.

10

11

3 L’ordonnancement du Job shop Le job shop est associé à des lignes de production dédiées à la production de moyennes et de petites séries où les changements de produits sont fréquents (généralement les produits à fabriquer présentent des caractéristiques différentes). Chaque travail passe sur les machines selon une gamme fixée. Cette gamme peut être différente pour chaque travail. On parle ainsi d’un atelier à flot multidirectionnel.

3.1 Formalisation du job shop Un problème de job shop peut donc être formalisé ainsi (définition par Vaessens en 1994) : Un problème P de job shop de taille n×m est constitué d’un ensemble O de l opérations, d’un ensemble M de m machines et d’un ensemble J de n jobs. A la jème opération du ième job noté oij correspond un temps opératoire poij € N et une seule machine Moij € M sur laquelle elle s’effectue. Chaque job Ji est constitué d’une séquence Oi = (Oi1, Oi2,…, Oiki) de ki opérations. L’ordre de séquencement exprime en réalité les contraintes technologiques. Les jobs peuvent être associés à des dates de début au plus tôt ri avant lesquelles il n’est possible d’effectuer aucune exécution. Les machines demandent généralement une certaine durée de préparation et ne pauvent être disponible qu’à partir d’une date ui. Les différents paramètres de temps : p, r et u sont généralement des entiers. Une relation binaire A est définie dans l’ensemble O représentant les relations de précédence entre les opérations. Si (v, w) € A alors v doit s’exécuter avant w. A induit un ordre total entre les opérations d’un même job. De plus, aucune des contraintes de précédence n’existe entre les opérations des différents jobs.

3.2 Contraintes et objectifs Le problème de job shop présente des hypothèses à respecter :

- Les machines ne sont pas identiques : chaque machine est unique. Lors de l’affectation, aucune question de type « sur quelle machine une opération doit s’effectuée ne peut se poser » ;

- les opérations d’un même job s’exécutent séparément sur les machines en respectant l’ordre des séquences Oi ;

- La préemption des opérations n’est pas permise : une fois une opération commencée, elle doit être terminée ;

- toutes les données du job shop sont connues d’avance : il s’agit alors du job shop statique (en particulier, il ne doit pas y avoir des nouveaux jobs lors de l’exécution des anciens.) ;

- Les machines ont une disponibilité infinie. Elles sont supposées fiables et ne subissent aucune panne pouvant perturber ou arrêter l’exécution des opérations.

- Les problèmes de job shop classiques, appelés aussi carrés, traitent généralement des jobs ayant un nombre d’opérations égal au nombre de machines. Ainsi toutes les opérations d’un même job shop s’exécutent sur des machines différentes.

L’exemple que nous avons traité en priorité est un problème de job shop carrés de taille 6×6. Il satisfait toutes les contraintes citées auparavant. Les critères d’optimisation étudié sont le makespan (correspondant à la date de fin de la dernière opération effectué pour l’ensemble des jobs) et le flot total (qui vaut la somme des encours)

3.3 Représentation graphique du job shop Le job shop peu être décrit par un graphe de précédence G et son diagramme de Gantt associés :

Job shop de taille 3*3

Diagramme de Gantt représentant l’ordonnancement job shop 3*3

12

4 Les algorithmes génétiques. Parmi les méthodes permettant de résoudre les problèmes d’ordonnancement, les méthodes basées sur les algorithmes évolutifs constituent une approche originale. Le but de ces méthodes n’est pas forcément d’obtenir la solution optimale, mais plutôt de proposer des solutions satisfaisante dans un temps plus court qu’une méthode exacte. En effet, les méthodes exactes demandent un temps de calcul et des processeurs trop important face à la rapidité des algorithmes évolutifs. Plusieurs variantes des algorithmes évolutifs ont été développées mais nous nous sommes penchés uniquement sur les algorithmes génétiques.

4.1 Principe des algorithmes génétiques Les algorithmes génétiques s’inspirent du fonctionnement de l’évolution de la nature. Ils sont basés sur le principe d’évolution d’une population d’individus. Dans une population d’individus, ce sont en général les plus forts, c’est-à-dire les mieux adaptés au milieu, qui survivent et engendrent des progénitures. Sur ce schéma, on crée une population de solutions admissibles. Puis on évalue chacune des solutions. On élimine une partie des solutions les plus mauvaises puis on recombine les gènes afin d’obtenir une nouvelle population de solutions. Ainsi, à chaque génération, on crée un nouvel ensemble de solution à partir des meilleurs éléments des populations antérieures. On crée cette nouvelle population ”en mélangeant” des éléments des solutions de l’ancienne génération. En réitérant ce processus, on parvient à trouver des solutions intéressantes. Un intérêt supplémentaire des algorithmes génétiques est qu’ils permettent l’optimisation multicritère. Pour mieux comprendre le lien entre les algorithmes génétiques et l’évolution naturelle, rappelons les liens entre la terminologie naturelle et celle des algorithmes génétiques.

Pour mettre en œuvre un algorithme génétique, il est donc nécessaire de disposer : - d’une représentation génétique du problème, c’est-à-dire d’un

codage approprié des solutions sous la forme de chromosomes. La qualité du codage des données conditionne le succès des algorithmes génétiques ;

- d’un mécanisme de génération de la population initiale. Ce mécanisme doit être capable de produire une population d’individus non homogène qui servira de base aux générations futures. Il est important que la population initiale soit répartie sur tout le domaine de recherche ;

13

14

- d’une fonction évaluation pour mesurer la force de chaque chromosome ;

- d’un mode de sélection des chromosomes à reproduire ; - des opérateurs permettent de diversifier la population au cours

des générations et d’explorer l’espace d’état. L’opérateur de croisement recompose les gènes d’individus existant dans la population ; l’opérateur de mutation a pour but de garantir l’exploration de l’espace des états.

- des valeurs pour les paramètres qu’utilise l’algorithme : taille de la population, nombre total de générations ou critère d’arrêt, probabilités de croisement entre [0,7 ; 0,99] % et de mutation entre [0,0001 ; 0,01].

Un algorithme génétique fonctionne typiquement à travers un cycle simple de quatre étapes :

1. création d’une population de chromosome ; 2. évaluation de chaque chromosome ; 3. sélection des meilleurs chromosomes ; 4. manipulation génétique pour créer une nouvelle population de

chromosomes. Voici le cycle décrit :

4.2 La notion d’algorithme génétique multicritères Pour un algorithme génétique, on ne s’intéresse qu’à l’optimisation d’un seul critère. Mais la solution obtenue n’est pas forcément la meilleure pour les autres critères. D’où la nécessité de pouvoir comparer des solutions sur plusieurs critères différents. Lorsque une solution est meilleure qu’une autre par rapport à un critère, on dit qu’elle est dominante ou Pareto optimale. Par exemple, une solution pourra être optimale pour le critère du Cmax alors qu’elle ne l’est pas pour celui du flot total. Dans ce cas la solution optimale pour le flot total ne le sera pas non plus pour le Cmax. L’intérêt de cette technique est d’obtenir des solutions Pareto optimales, c’est-à-dire des solutions qui satisfont aux mieux les différents critères testés. Mais le fait que l’on teste différents critères et que l’on ait seulement quelques solutions à chaque exécution du problème nous oblige à le relancer plusieurs fois pour obtenir des solutions Pareto optimale. Cependant, comme l’algorithme génétique traite des populations de solutions, il nous donne plusieurs solutions proche de l’optimale à chaque exécution. Ce qui nous donne beaucoup plus de chances de trouver des solutions Pareto optimales en un nombre raisonnable d’exécutions du programme.

15

5 La résolution d’un problème de job shop par les algorithmes génétiques multicritères.

5.1 L’exemple traité Nous nous sommes donc penchés sur la résolution d’un problème d’ordonnancement job shop par les algorithmes génétiques. Pour mieux comprendre le fonctionnement des ces algorithmes, nous avons choisi de traiter un exemple précis puis de généraliser. L’exemple que nous avons traité est le job shop de taille 6*6 proposé par Fischer et Thomson. Nous vous présentons ici la manière dont nous avons procédé ainsi que les choix que nous avons fait pour la réalisation du projet. Les fonctions les plus importantes dans la recherche de la solution sont détaillées sous forme algorithmique. Nous avons essayé de les simplifier au maximum mais elles demandent une certaine concentration pour leur compréhension.

Jobs Opérations (Mi, ti) 1 3,1 1,3 2,6 4,7 6,3 5,6 2 2,8 3,5 5,10 6,10 1,10 4,4 3 3,5 4,4 6,8 1,9 2,1 5,7 4 2,5 1,5 3,5 4,3 5,8 6,9 5 3,9 2,3 5,5 6,4 1,3 4,1 6 2,3 4,3 6,9 1,10 5,4 3,1

5.1.1 Le codage des chromosomes La première chose à faire a été de choisir une manière simple de coder nos chromosomes. Nous avons choisi d’utiliser un codage par machine. C’est-à-dire que chaque chromosome (solution) est constitué d’une matrice M*N où M est le nombre de machines et N le nombre d’opérations effectuées sur chaque machine. Sur chaque ligne, on aura donc la succession des opérations élémentaires à effectuer sur la machine correspondante. Une tâche, quant à elle, est définie par un couple d’entier correspondant au numéro de job et au numéro de l’opération. On obtient ainsi un chromosome codé comme ci-dessous.

Machine 1 1,2 2,5 3,4 4,2 5,5 6,4

Machine 2 1,3 2,1 3,5 4,1 5,2 6,1

Machine 3 1,1 2,2 3,1 4,3 5.1 6,6

Machine 4 1,4 2,6 3,2 4,4 5,6 6,2

Machine 5 1,6 2,3 3,6 4,5 5,3 6,5

Machine 6 1,5 2,4 3,3 4,6 5,4 6,3

16

Chaque opération possède également un entier correspondant à la durée nécessaire pour sa réalisation. Sa date au plus tôt lui est affectée en fonction de la date de fin de l’opération précédente. Sa date de début correspond à l’instant où son exécution débute sur la machine. En plus de ce tableau d’opération, on affecte à chaque chromosome les valeurs de son Cmax et de son flot total. C’est à partir de ce codage que nous avons ensuite pu programmer les différentes procédures. Algorithme de la méthode setOperation Entrée : Une matrice de job 6*6 Sortie : Un tableau d’opération du chromosome correspondant Début : Initialisation du chromosome initial Parcourir la matrice de job par ligne et les mettre dans la ligne de la machine correspondante Fin

5.1.2 Description de l’algorithme L’algorithme utilisé est basé sur les différents articles que nous avons pu lire avant de commencer ce projet. Nous avons suivi exactement le déroulement décrit plus tôt dans ce rapport ; à savoir :

• la génération d’une population initiale ; • l’évaluation et la sélection de nos chromosomes ; • les croisements et mutations entre les chromosomes d’une population • la réparation des chromosomes non réalisables ainsi que leur amélioration

pour obtenir des solutions faisables ; • obtention d’une nouvelle population pour l’itération suivante

5.1.3 Génération d’une population de chromosomes (réparation de chromosome)

Une population sera définie comme un tableau de chromosomes. Pour obtenir une première population de chromosomes, nous avons d’abord cherché à en créer un ; puis en inversant des colonnes dans notre tableau d’opération, nous en avons créé plusieurs. Afin d’être sur que le chromosome soit réalisable (c’est-à-dire que l’ordre de précédence des opérations soit respecter) nous avons créé une procédure réparer chromosome qui nous permet de dire si le chromosome est faisable ou pas. Si oui, on le met dans notre population initiale de chromosome, sinon, on le répare pour le rendre réalisable. On réitère ce processus jusqu’à ce que notre chromosome soit valable. Lorsque nous avons obtenu une population de chromosomes, nous avons cherché à définir les opérateurs génétiques de croisement et de mutation.

17

5.1.4 Opérateurs de mutation et de croisement La mutation est un événement rare dans la nature. Il donne à un individu des caractéristiques qui ne figurait pas dans le génotype de ces parents. C’est donc un événement rare qui nous permet de ne pas tomber dans des extrema locaux. Pour notre problème nous avons choisi de voir la mutation comme une inversion impromptue entre deux opérations de notre tableau d’opération. Cette inversion d’opération s’effectuera bien sûr sur une même ligne de notre tableau puisque elle aura lieu entre deux opérations exécutable par une machine. En effet dans un problème de job shop, une machine ne peut réaliser qu’une et une seule opération. Algorithme de la méthode Mutation Entrée : Un chromosome père, pourcentage de mutation p Sortie : Un chromosome fils muté Début : Initialisation du chromosome fils par duplication du père Pour i variant de 1 à 6 (nombre total de lignes) par pas de 1Faire

Pour j variant de 1 à 6 (nombre total de colonnes) par pas de 1 Faire On tire pour chaque opération un nombre aléatoire a Si a<p

On tire un deuxième nombre aléatoire n Є [0 ; 6] On intervertit les opérations i et n FinSi FinPour FinPour Fin Pour effectuer un croisement nous avons besoins de deux chromosomes. A partir de ces deux chromosomes, nous allons en créer deux nouveaux. Nous choisirons donc un chromosome “père“ et un chromosome “mère” parmi les chromosomes de notre population. Ils engendreront deux chromosomes fils selon le mécanisme suivant : Pour chaque ligne de notre tableau d’opération :

On choisit aléatoirement deux points de coupures qui sont les mêmes pour les deux parents. Les opérations du père situées entre les deux points de coupures sont copiées dans un nouveau tableau d’opérations, de même pour la mère.

Ensuite les deux nouveaux tableaux obtenus sont remplis a au fur et à mesure avec les opérations restantes de l’autre parent. Voici comment nous procédons. Prenons le tableau du fils 1 qui a reçu les opérations entre les points de coupures venant du père. On remplit le reste de son tableau avec les opérations venant de la mère et qui n’était pas entre ces mêmes points de coupures. Dans le cas où l’opération venant de la mère est déjà présente dans les opérations reçues du père, on passe à la suivante. On parvient ainsi à créer un nouveau chromosome. On procède de même pour le fils 2.

L’opérateur de croisement nous permet donc d’obtenir deux chromosomes distincts à partir de deux chromosomes de la population précédente.

18

Algorithme de la méthode Croisement Entrée : Un chromosome père, Un chromosome mère Sortie : Deux chromosomes fils1 et fils 2 croisés Début : Initialisation des chromosomes fils Pour i variant de 1 à 6 (nombre total de lignes) par pas de 1Faire

On tire pour chaque ligne deux nombres aléatoires a et b qui sont les points de coupures

Pour j variant de a à b par pas de 1 Faire Les chromosomes fils1 et fils2 reçoivent respectivement les opérations situées

entre les points de coupure des chromosomes père et mère On note le numéro des jobs recopiés dans un tampon (tableau de taille [2][6]) FinPour Pour j variant de 1 à 6 (nombre total de colonnes) par pas de 1 Faire On remplit chaque chromosome fils en parcourant l’autre chromosome parent

Si le numéro de job Є tampon On lit l’opération suivante Sinon On ajoute l’opération au chromosome fils FinSi

FinPour FinPour Fin

5.1.5 Evaluation et sélection du chromosome Nous avons choisi d’évaluer nos chromosomes suivant la valeur de leur Cmax. Pour chaque chromosome d’une population donnée, on calcule donc le Cmax qui est la date de fin de la dernière opération réalisée. Ensuite, on trie les chromosomes de la population par ordre croissant du Cmax. On affecte ensuite un pourcentage de chance d’être choisi à chaque chromosome suivant ce même critère, le chromosome ayant le plus petit Cmax ayant le plus de chance d’être choisi (100%). La sélection consiste donc à choisir les chromosomes parmi ceux qui ont le meilleur Cmax.

5.1.6 Faisabilité du chromosome (procédure Gantt) Dans notre programme, nous considérons qu’un chromosome est réalisable si nous arrivons à exécuter toutes les opérations du tableau d’opération en respectant toutes les contraintes, c’est-à-dire toutes les relations de précédences. Cette vérification est réalisée par une procédure que nous avons appelé Gantt en référence au nom des diagrammes d’ordonnancement.

19

Algorithme de la méthode Gantt Entrée : Un chromosome p Sortie : Un chromosome réalisable, et améliorer avec ses valeurs de C Max et Flot Total Début : tampon_job [6],tampon_machine[6],temoin_machine[6][3][6], tableau_machine[6] temoin_machine[j][1][i] : temps à partir duquel il y a le trou i sur la machine j temoin_machine[j] [2][i] :durée du trou i sur la machine j temoin_machine[j] [3][i] :position de la tâche suivante sur la machine j tableau_machine[i] : durée des opérations sur la machine i Faire

On initialise tous nos tampons (job, machine, témoin machine, …) à 0 Pour i variant de 1 à 6 par pas de 1 Faire

Tampon_job[i]←les tâches bloquantes par job Tampon_machine[i] ←les tâches en cours de la machine i

FinPour Faire Pour i variant de 1 à 6 par pas de 1 Faire

Pour j variant de 1 à 6 par pas de 1 Faire Si Tampon_job[i] = Tampon_machine[j] Indic←vrai Si Tampon_job[i].date_plus_tot > tableau_machine[j].durée Alors on ne peut pas faire l’opération i tout de suite a← Tampon_job[i].date_plus_tot- tableau_machine[j].durée Flot← flot+ a

temoin_machine[j][1][position du trou] ← tableau_machine[j].durée temoin_machine[j][2][ position du trou] ←a

temoin_machine[j][3][ position du trou] ← position de l’opération +1 position du trou++ tableau_machine[j].duree← Tampon_job[i].date_plus_tot FinSi On ajoute à notre machine la durée de l'operation traitée On augmente le flot de la même durée On passe dans notre tampon_job à l’opération suivante On passe dans notre tampon_machine à l’opération suivante FinSi FinPour

FinPour TantQue(indic=vrai) Si on n’a pas parcouru toutes nos taches bool←faux reparer_chromosome(p) FinSi TantQue(bool=faux) On lui attribue ses C Max, Flot total et Flot moyen Indice_ameliorer←faux Ameliorer(p, temoin_machine, Indice_ameliorer)

20

Si Indice_ameliorer=vrai Gantt(p) finSi Fin A chaque fois qu’un chromosome est créer (peu importe la manière), on vérifie si l’ordonnancement qu’il décrit est réalisable ou pas. Si il ne l’est pas, alors, on cherche quelle est l’opération bloquante et on l’échange avec une autre opération de la même machine (la même ligne dans notre tableau d’opérations). Dans le cas où plusieurs opérations sont bloquantes, on préférera débloquer celle qui a le plus petit numéro de tâche. Cette procédure peut ne pas suffire à rendre le chromosome réalisable en une seule fois, on re-teste donc notre chromosome jusqu’à ce qu’il soit réalisable. Algorithme de la méthode Reparer Entrée : Un chromosome, les tableaux tampon_job et tampon_machine Sortie : Un chromosome valide Début : min←7 Pour i variant de 1 à 6 par pas de 1 Faire Si tampon_job[i].numero_tache<min min← tampon_job[i].numero_tache z←i FinSi FinPour Tampon_a← tampon_job[z] L’opération z est celle qu’il faut débloquer On affecte à tampon_b l’opération qui bloque l’exécution sur la machine où il y a tampon_a On échange les deux opérations entre elles Fin

21

5.1.7 Amélioration du chromosome (ordonnancement sans retard) Nous nous sommes ensuite rendus compte que les chromosomes que nous obtenions grâce à nos opérateurs génétiques pouvaient encore être amélioré. En effet, il subsiste parfois des “trous“ dans l’ordonnancement obtenu. C’est-à-dire qu’une opération dont les précédentes ont déjà été réalisées n’est pas exécutée aussi vite qu’elle le pourrait, mais après d’autres opérations. Or le laps de temps entre les dates de fin et les dates de début de ces autres opérations peut être suffisant pour y intercalées l’opération en question. Le sujet qui nous était proposé nous demandait de mettre en œuvre un algorithme génétique multicritère. Nous avons donc calculés le flot total et le Cmax de chaque chromosome trouvé au cours de l’algorithme. Nous les avons comparé à chaque fois avec les chromosomes jusque là obtenus pour déterminer les chromosomes dominants. Algorithme de la méthode Ameliorer Entrée : Un chromosome p, le tableau temoin_machine Sortie : Un chromosome améliorer, indic Début : indic←faux Pour chaque trou ; pour chaque machine

Pour chaque tâche de la machine Si date début de la tâche j > début du trou i Si date au plus tôt de la tache j ≥ début du trou i Si durée de la tâche j ≤ durée du trou i On insère l’opération j au début du trou i indic←vrai FinSi FinSi FinSi FinPour

FinPour FinPour Fin

6 Déroulement du programme L’exécution du programme se déroule comme suit :

6.1 Choix du problème

Ici l’utilisateur choisit soit :

• De résoudre le problème 6*6 de Fisher & Thomson

• De résoudre un problème 6*6 générer aléatoirement.

A la suite de cela, l’utilisateur doit rentrer le pourcentage de croisement, de mutation et le nombre d’itérations qu’il souhaite. Ensuite, l’utilisateur peut choisir entre un mode de sélection par classement : « super héros » ou un mode de sélection par roulette « somme des fitness ». Remarque : Les résultats obtenus par le second mode de sélection ne sont pas à la hauteur de se que l’on pouvait espérer (Avec ce mode de sélection nous n’avons pas réussi à obtenir la solution optimale du problème de Fischer & Thomson).

22

6.2 Choix du mode de sélection

6.3 Premier chromosome généré L’utilisateur voit maintenant s’afficher le premier chromosome générer.

23

Puis l’écran affiche l’état d’avancement du programme

24

6.4 Résultats et enfin, les chromosomes dominants s’affichent.

25

26

7 Déroulement du projet

Dans cette partie nous présentons le déroulement chronologique de notre projet.

7.1 Documentation Les deux premières semaines du projet ont été entièrement consacrées à la compréhension du sujet. Durant ces deux semaines nous nous sommes familiarisé aux notions de job shop, d’ordonnancement et d’algorithmes génétiques.

7.2 Programmation

7.2.1 Codage Après une première phase de documentation, nous nous sommes attaqués à la programmation de l’algorithme. La première difficulté a été de trouver un codage de nos chromosomes permettant de définir une solution possible du problème.

7.2.2 Génération de la population

Une fois le codage trouvé, il a fallut générer plusieurs chromosomes différents afin de constituer une population. Nous avions d’abord pensé à obtenir notre première population de chromosome en mutant le premier que nous avions obtenu plusieurs fois. Mais cela ne générait pas forcément des chromosomes faisables. Nous avons donc fait des inversions entre les colonnes de notre tableau d’opération pour générer des chromosomes de manière simple et rapide.

Le codage que nous avons choisi d’utiliser présente l’avantage d’être très prés de la réalité. Mais lors de la génération de chaque nouvelle population nous nous sommes rendus compte que certains des nouveaux chromosomes pouvaient s’avérer infaisables.

7.2.3 GANTT & réparation Nous avons donc écrit une nouvelle procédure pour vérifier la faisabilité de chaque chromosome obtenu après croisement ou/et mutation. Par la suite nous nous sommes également rendus compte que le fait d’écarter les chromosomes non valides prenait du temps et ne nous permettait d’obtenir suffisamment de chromosomes valides dans les premières itérations. Nous avons donc écrit une nouvelle procédure permettent de « réparer » le chromosome en échangeant la tache bloquante avec une tache réalisable dés que le chromosome se révèle non admissible. Le problème suivant a été de programmer une fonction évaluation sur nos deux critères (makespan et le flot total). A partir de cette fonction évaluation, nous avons choisis de trier nos chromosomes par ordre de flot total et de Cmax dans une pile. Nous avons ensuite affecté un poids à chaque chromosome. (Le premier chromosome ayant une probabilité d’être choisi de

27

100%). Le mode de sélection consistait donc à choisir les chromosomes en comparant leur pourcentage de chance d’être choisi avec un entier générer aléatoirement.

7.3 Evolution des résultats

7.3.1 Premier résultat sur le problème 6*6 Pour une population initiale de 100, un pourcentage de croisement de 80%, de mutation de 15% et 9990 itérations le meilleur résultat obtenu est de 67 (pour un résultat optimal connu de 55). Remarque. Lors de la dernière itération, on constate que si l’on affiche les chromosomes de la dernière itération, ceux-ci sont tous identiques. Plusieurs hypothèses peuvent expliquées ceci, mais nous pensons à la thèse du super héros.

7.3.2 Réunion du 15 avril 04 : Premiers résultats obtenus pas assez bons : trop d’itérations, et un pourcentage de mutation trop élevé.

Solutions envisagées : • agrandir la population initiale entre 400 et 700 chromosomes. • modifier la sélection : pour chaque chromosome on affecte une

probabilité de sélection égale à somme des Cmax sur le Cmax du chromosome. Puis on fixe aléatoirement un nombre entre 0 et 1. Enfin, on somme les probabilités des chromosomes choisis aléatoirement jusqu’à obtenir un nombre supérieur à celui choisi. Le dernier chromosome permettant de dépasser la valeur choisie est sélectionné. On réitère ce processus pour obtenir une population de la taille voulue.

• Améliorer la procédure de réparation en regardant si il est possible de transformer un ordonnancement semi-actif en un ordonnancement sans retard (« sans trou »). Cela consiste à regarder pour chaque machine si une des tâches peut être réalisée plus tôt sur le diagramme de Gantt ; c’est-à-dire si toutes les opérations précédent la tâche considérée ont été exécutées et que la machine réalisant cette tâche dispose d’un temps suffisant entre deux tâches pour réaliser l’opération. Cette procédure nous permettrait d’obtenir des ordonnancements sans retards (que nous ne pouvons obtenir à coup sûr autrement).

• Après chaque modification établir l’amélioration obtenue et la conclusion

OBJECTIF : diminuer le pourcentage de mutation (1%) et diminuer le nombre d’itération (500,1000)

7.3.3 Ameliorer A partir de cette réunion, il a été décidé de programmer une procédure permettant de « combler les trous ».

7.3.4 Résultats obtenus : La programmation de la procédure amélioration nous a permis d’obtenir immédiatement un chromosome de Cmax 58. Après quelques itérations nous avons obtenu le résultat optimal cherché (55) avec un pourcentage de croisement de l’ordre de 80% et un pourcentage de mutation de l’ordre du pour mille. Ces résultats sont donc encourageants.

7.3.5 Réunion du 6 mai 04 : Le prochain objectif est donc d’utiliser les algorithmes génétiques multicritères pour trouver toutes les solutions dominantes (Pareto optimales) à un problème donné.

Une solution sera Pareto optimale si les deux critères testés d’un chromosome sont supérieurs à ceux des autres avec un des deux critères supérieur ou égal. Si pour deux chromosomes donnés on a des inégalités entre le deux critères dans des sens opposés alors ils ne sont pas comparables ils peuvent être optimaux au sens de la Pareto optimalité. Le deuxième objectif était de générer aléatoirement des problèmes de taille 6*6 afin de tester notre algorithme.

7.3.6 PARETO A partir des chromosomes obtenus lors des itérations et de la formule de dominance précédente, nous avons pu classer les chromosomes.

Les résultats obtenus sont écris dans un ficher texte dans le répertoire pour pouvoir tracer des graphes.

7.3.7 Générer Problème Dans un dernier temps, nous avons écrit une nouvelle procédure qui nous permet

de générer aléatoirement des problèmes d’ordonnancement de job shop de taille 6*6. Nous nous sommes limités à des exemples de tailles 6*6 du fait de notre choix de codage. En effet, le tableau d’opérations de nos chromosomes est une structure de donnée un peu rigide qui nous compliquait la tâche pour passer à des problèmes de plus grande taille. Cela nous permettrait de tester notre programme sur différents problèmes connus.

7.4 Les derniers résultats obtenus Les résultats obtenus sur le problème de Fischer et Thomson sont de 55 pour le Cmax et 284 pour le flot total. Comme nous l’avons déjà dit, nos résultats ont été nettement meilleur après la programmation de la fonction améliorer. C’est cette méthode qui nous a permis de trouver des chromosomes sans retards. Ces chromosomes sont souvent considérés comme de bonnes solutions des problèmes d’ordonnancement. Ce dernier résultat obtenu pour un algorithme génétique monocritère est donc satisfaisant. Par contre la programmation de la méthode Pareto qui nous permet de trouver les solutions par un algorithme génétique multicritère n’a pas fournit les résultats obtenus. En effet, nous n’avons obtenu comme résultat qu’un seul chromosome dominant.

28

Néanmoins, nous expliquons ce résultat par le fait qu’il est probable qu’il n’y en ait qu’un (ou qu’ils soient peu nombreux). Les deux critères étudiés nous ont en effet semblés être très corrélés. Il nous a semblé logique que la somme des encours (le flot total) soit plus faible si la dernière tâche exécutée (le Cmax) se termine plus tôt.

7.5 Plan de charges

Tâches Février Mars Avril Mai

Documentation

Codage des chromosomes

Croisement & Mutation

Gantt (évaluation) & réparation

Sélection

Amélioration

2ème type de sélection

Pareto, Ecriture dans un fichier, Génération de

problème

Rapport & Power point

29

Projet réalisé par 2 étudiants à raison de 10 h/semaines pendant 12 semaines = 440h

7.6 Améliorations possibles A ce niveau du projet, nous pouvons dire que plusieurs changements sont possibles afin d’améliorer le rendement de notre programme.

• Faire du code en C++ avec des classes nous aurait permis d’avoir un code plus propre et plus adaptable à des problèmes de job shop plus grand et non carré.

• Diversifier la population initiale en produisant plus de chromosomes nous aurait permis d’élargir le domaine de recherche.

• Vérifier que les chromosomes déjà présents ne soient pas remis dans la population. (On évite ainsi une convergence prématurée vers la solution)

• Améliorer notre deuxième type de sélection. • Coder le chromosome en le lisant par tache plutôt que par job nous aurait permis

d’obtenir des chromosomes plus proches de la solution recherchée.

30

8 Conclusion Ce projet nous a donc permis de mieux comprendre l’importance d’une bonne gestion des tâches dans un ordonnancement, et plus particulièrement d’un ordonnancement de job shop. Il nous paraît désormais clair que les algorithmes génétiques sont de bonnes applications à mettre en œuvre pour trouver des solutions proches de l’optimale en des temps de calcul raisonnables. Notre algorithme génétique multicritère n’a pas réellement fonctionner aussi bien que prévu puisque nous ne trouvons qu’une solution Pareto optimale. Mais nous avons tout de même compris leur intérêt. Dans la vie réelle, on a souvent plusieurs critères à optimiser. Ces algorithmes permettent de trouver de bonnes solutions (non-nécessairement optimales) pour chacun des critères étudiés. Mais, elles donnent en moyenne les meilleures solutions pour les critères traités. Ce projet nous a donc été très profitable puisque nous avons énormément appris sur les algorithmes génétiques et leur utilisation. Nous regrettons cependant de ne pas avoir eu plus de temps pour pouvoir améliorer encore notre algorithme (en particulier les deux modes de sélection) afin de pouvoir le tester sur d’autres problèmes déjà résolus.