Partitionnement de graphe

Université catholique de
Louvain

Institut de la Francophonie
pour l’Informatique

Partitionnement de Graphe
Promoteur :
Yves Deville

Mémoire présenté en vue de l’obtention du
grade de master informatique
par
Duong Khanh Chuong

Hanoi
Novembre, 2009


Remerciements
Je tiens d’abord à remercier tout particulièrement mon
promoteur, Monsieur Deville, pour l’encadrement, l’aide et les
idées qu’il m’a donné pendant toute la durée du stage.
Je voudrais remercier tous les membres de l’équipe BeCool
(Belgian Constraint Group) pour leur accueil chaleureux, leur
soutien et leurs conseils sans lesquels ce travail n’aurait pu
aboutir.
J’adresse mes sincères remerciements à tous les professeurs de
l’IFI pour m’avoir enseigné et m’inspirer pendant mes études au
master.
Finalement, j’exprime mon entière reconnaissance à ma famille et

mes amis pour leur soutien, leur aide et leurs encouragements.

Page 2


Résumé
Le problème du partitionnement de graphe a pour but de découper un graphe en différentes parties
(partitions) qui satisfont certains contraintes (telle que l’équilibre des parties) et qui optimisent une
certaines fonction objectif (telle que le coût de coup). Il possède de nombreuses applications comme
la conception de circuits intégrés électroniques, la répartition de charge pour les machines parallèles
ou la segmentation d’images. Cependant, le partitionnement de graphe est un problème complexe
(NP-complet), dont la solution ne peut pas être trouvée au moyen d’une méthode de résolution
exacte. Pour ce type de problème, la recherche locale est une approche adéquate. Dans ce travail,
nous avons étudié et analysé des méthodes de partitionnement classiques comme la méthode de
glouton, le multi-niveaux ou les algorithmes de type Kernighan-Lin et des méthodes de recherche
locale comme la recherche taboue et le recuit simulé.
Enfin, nous avons implémenté les méthodes présentées dans ce mémoire dans COMET, et nous
avons comparé leur performance et leur efficacité avec le logiciel METIS.
Mots clés : partition, recherche locale, multi-niveaux, contraction, affinage

Page 3


Abstract
The graph partitioning problem consists of dividing a graph into parts (partition) which satisfy some
constraints (such as the balance of parts) to optimize an objective function (such as the sum cut of
edges). It has many applications: design of integrated electronic circuits, load balancing for parallel
machines or image segmentation. However, graph partitioning is known to be NP-complete, so there
is no exact solution and the local search is one of appropriate approach. In our work, we have studied
and analyzed classic partitioning methods such as the greedy, the multi-level or algorithms of

Kernighan-Lin and methods of local search such as Tabu search and simulated annealing.
Finally, we have implemented those methods in COMET, and then we compared their performance
and efficiency with the software METIS.
Key words: partition, local search, multi-level, coarsening.

Page 4


Table des matières
1. Partitionnement de Graphe ...................................................................................... 9
1. 1. Définition .......................................................................................................................................... 9
1. 2. Contraint......................................................................................................................................... 10
1. 3. Fonction d’objectives ..................................................................................................................... 11
1. 4. Applications .................................................................................................................................... 11

2. Etat de l’art ............................................................................................................ 13
2. 1. Méthodes classiques ...................................................................................................................... 13
2. 2. Méthodes de métaheuristiques ..................................................................................................... 17

3. Recherche locale et Comet ..................................................................................... 20
3. 1. Recherche locale ............................................................................................................................ 20
3. 2. Le langage Comet ........................................................................................................................... 22

4. Méthode de Multi Niveaux ..................................................................................... 25
4. 1. Principale ........................................................................................................................................ 25
4. 2. Contraction ..................................................................................................................................... 25
4. 3. Partitionnement ............................................................................................................................. 27
4. 4. Affinage .......................................................................................................................................... 28

5. Méthode de Recherche Locale................................................................................ 32

5. 1. Recherche Taboue .......................................................................................................................... 32
5. 2. Recherche de Recuit Simulé ........................................................................................................... 34

6. Expérimentation .................................................................................................... 37
6. 1. Environnement d’expérimentation ................................................................................................ 37
6. 2. Résultat........................................................................................................................................... 39

7. Conclusion ............................................................................................................. 41
Références ................................................................................................................. 42

Page 5


Liste des figures
Figure 1. Partitionnement de Graphe avec k=4 ..................................................................................... 10
Figure 2. L'idée principale de l’algorithm de Kernighan-Lin ................................................................. 15
Figure 3. Schéma de méthode Multi-niveaux ........................................................................................ 16
Figure 4. Comparaison entre des méthodes classiques de partitionnement du graphe ...................... 17
Figure 5. Représentation de l'espace de recherche de recherche locale .............................................. 22
Figure 6. Architecture de COMET .......................................................................................................... 23
Figure 7. Méthodes différents pour la contraction ............................................................................... 26
Figure 8. Exemple de l'échange de deux sommets ................................................................................ 29
Figure 9. Algorithme de Kernighan-Lin .................................................................................................. 30

Page 6


Introduction
Le partitionnement de graphe est une technique très connue en informatique. Etant donné un
graphe non-orienté G = (S, A), on partitionne l’ensemble des sommets S à k sous-ensembles disjoints

tels que la taille du sous-ensemble le plus grande est minimale.
Ce problème est utilisé pour résoudre un grand nombre de problèmes d’ingénierie: la conception de
circuits intégrés électroniques, la répartition de charge pour les machines parallèles, la dynamique
des fluides, le calcul matriciel, la segmentation d’images ou la classification d’objets.
Le partitionnement de graphe est un problème NP-complet. Dans la littérature, Il existe plusieurs
techniques et des logiciels qui donnent des bons résultats comme : Chaco(1), SCOTCH(2), JOSTLE(3),
METIS(4), …
Ce stage a pour but de concevoir, développer et analyser différentes méthodes pour le problème de
partitionnement de graphe.
Les méthodes présentées dans cette mémoire sont les suivantes: méthode de glouton, l’algorithme
de Kernighan-Lin, méthode de multi-niveaux, des métaheuristiques comme le recuit simulé et le
recherche Tabou. Afin de tester la qualité de ces méthodes, nous implémentons ces méthodes dans
l’environnement de Comet et comparons avec le logiciel Metis(4).
Cette mémoire est composée de 7 chapitres qui se présentent comme suit:
Chapitre 1: Partitionnement de graphe
Introduction au problème de partitionnement de graphe : la définition, les contraintes, l’objectif et
les applications
Chapitre 2: Etat de l’art
Présentation des techniques présentées dans la littérature.
Chapitre 3: Recherche locale et Comet
Description de la recherche locale et du langage Comet
Chapitre 4: Méthode de Multi-Niveaux
Présentation détaillée de la méthode Multi-Niveaux et de son implémentation dans Comet
Chapitre 5: Méthodes de Recherche Locale
Description détaillée des méthodes : recherche Tabou et recuit simulé, et de leur implémentation
dans Comet

Page 7

Chapitre 6: Expérimentation
Expérimentation des 3 méthodes implémentées et comparaison avec la logiciel Metis
Chapitre 7: Conclusion
Conclusion du mémoire et explication des perspectives dans lesquelles le travail pourrait être
poursuivi

Page 8


1
Partitionnement de Graphe
1. 1. Définition
Partitionnement
Le mot “partitionnement” correspond au mot « partitioning » en anglais, qui exprime la création
d’une partition. La partition est le résultat de la division en parties d’un ensemble. En
mathématiques, une partition d’un ensemble E est une famille de sous-ensembles de E tels qu’elles
sont disjointes deux à deux et la réunion dont est l’ensemble E.

Partitionnement de graphe
Etant donné un graphe non-orienté G = (S, A), où S est l’ensemble des sommets et A est l’ensemble
des arrêtes qui relient des paires de sommets. Les sommets et les arrêtes peuvent être pondérés, où
|s| est le poids du sommet s et |a| est le poids de l’arête a. Le problème du partitionnement de
graphe consiste à diviser G en k partitionnement disjointes. Au point de vue de mathématique, on
peut partitionner les sommets ou bien les arrêtes. Par contre, dans la plupart des applications, on ne
s’intéresse qu’au partitionnement des sommets de graphe.
Soient un graphe G = (S, A) et un ensemble de k sous-ensembles de S, noté Pk = {S1, S2,…, Sk}. On dit
que Pk est une partition de G si :
-

Aucun sous-ensemble de S qui est élément de Pk n’est vide :

∀𝑖𝜖 1, … , 𝑘 , 𝑆𝑖 ≠ 
Les sous-ensembles de S qui sont élément de Pk sont disjoins deux à deux

-

∀ 𝑖, 𝑗 𝜖 1, … , 𝑘
L’union de tous les éléments de Pk est S :

, 𝑖 ≠ 𝑗,

𝑆𝑖 ∩ 𝑆𝑗 = 

𝑘

𝑆𝑖 = 𝑆
𝑖=1

Les éléments Si de Pk sont appelés les parties de la partition

Page 9


Le nombre k est appelé le cardinal de la partition, ou encore le nombre de parties de la partition.
Dans le cas k = 2, on a le problème de bissection.

Figure 1. Partitionnement de Graphe avec k=4 (5)

1. 2. Contraint
Balance de partitionnement
Soient un graphe G = (S, A) et une partition Pk = {S1, S2,…, Sk} de ce graphe en k parties.

Le poids d’une partie Si de Pk est

poids(Si ) 

 poids(si)

siSi

Le poids moyen d’une partie Si de Pk est

poidsMoyen ( S , k ) 

 poids(s)
sS

k

La balance de la partition Pk est égale à la division du poids de la partie de poids maximal de Pk par le
poids moyen d’une partie :

ba lan ce( Pk ) 

max{po ids( S1 ), po ids( S 2 ),...., po ids( S k )}
po idMoyen( S , k )

La contraint de balance de partitionnement précise que la balance doit être moins qu’un seuil.
Ainsi, une partition dont la balance de partitionnement est unitaire a des parties de poids identiques

Page 10

1. 3. Fonction d’objectives
On défini le coût de coupe entre deux parties d’une partition Sa et Sb est la somme des arrêtes qui ont
deux bouts dans les deux parties :

coupe(Sa , Sb ) 

 poids(s , s )
a

saSa ,sbSb

b

(poids (sa, sb) est le poids de l’arête (sa, sb). Si il n’existe pas de l’arrête (sa, sb), le poids (sa, sb) = 0)
La plus simple des fonctions d’objectif est le coût de coupe d’une partition. Le but est à minimiser la
somme des poids des arrêtes entre les parties de la partition Pk. Dans le reste de cette mémoire, on
utilise cette fonction objectif dans tous algorithmes :

coupe( P k ) 

 coupe(S , S

i , j{1..k },i  j

i

j

)

La fonction objectif qui vise à minimiser pour chaque partie le rapport entre son coût de coupe et son
poids est appelée ratio de coupe :
𝑘

𝑟𝑎𝑡𝑖𝑜 𝑃𝑘 =
𝑖=1

𝑐𝑜𝑢𝑝𝑒(𝑆𝑖 , 𝑆 − 𝑆𝑖 )
𝑝𝑜𝑖𝑑𝑠(𝑆𝑖 )

Autre fonction objectif largement utilisée dans la littérature est le coût normalisé(6). Cette fonction
cherche à minimiser, pour chaque partie, le rapport entre son coût de coupe et la somme du poids
des arêtes adjacentes à au moins un de ses sommets. Cela veut dire qu’elle cherche à minimiser le
rapport entre la somme du poids des arêtes adjacentes à exactement un de ses sommets et la
somme du poids des arêtes adjacentes à au moins un de ses sommets. Cette fonction permet d’isoler
les régions où les sommets sont très liés entre eux. Elle est bien utilisé dans le problème de
segmentation d’image:
𝑘

𝑛𝑜𝑟𝑚𝑎𝑙𝑖𝑠é 𝑃𝑘 =
𝑖=1

𝑐𝑜𝑢𝑝𝑒(𝑆𝑖 , 𝑆 − 𝑆𝑖 )
𝑐𝑜𝑢𝑝𝑒(𝑆𝑖 , 𝑆)

1. 4. Applications
La conception de circuits intégrés électroniques
Le problème de conception de circuits intégrés électroniques est de diviser les composants aux souscircuits tels que le nombre de connexion entre ceux-ci soit minimal. C’est une tâche de plus en plus
complexe car les composants sont de plus en plus petits et les nombres de composants augment

rapidement.

Page 11


Un graphe peut être utilisé pour représenter un circuit électronique et ce problème devient le
problème de partitionnement de graphe. Les sommets représentent les composants et les arrêtes
représentent les connexions des composants.

La répartition de charge pour les machines parallèles
La répartition de charge pour les machines parallèles est pour but de répartir les charges de calcul
entre les processeurs et de réduire la durée des communications entre les processeurs.
Un graphe non-orienté permet de modéliser la répartition des charges pour les machines parallèles.
Les sommets du graphe représentent les blocs de calcul et les arrêtes sont correspondants aux
communications nécessaires à la programmation parallèles

La segmentation d’images
La segmentation d’images est pour but d’isoler les différents objets sur une image. Une image est
représentée par une matrice des pixels. Il est possible de créer un graphe de l’image, les sommets
représentent les pixels et les arrêtes sont correspondants la différence d’intensité lumineuse entre
les pixels

La classification
Les outils de classification permettent de trier un ensemble des objets afin de regrouper des objets
de même type. Il est donc possible de créer un graphe dont chaque objet est un sommet et chaque
arrête exprime la similarité entre deux objets.

Page 12

2
Etat de l’art
2. 1. Méthodes classiques
Greedy Graph Growing Algorithm (GGGP)
Le Greedy Graph Growing Algorithm (GGGP) a été introduit dans (7). Algorithme GGGP est pour
résoudre le problème de partitionnement de graphe avec k = 2 (bissection).Elle consiste à créer de
manière itérative un ensemble E. Cet ensemble est initialisé par un sommet par hasard. A chaque
itération, un des sommets adjacents aux sommets de l’ensemble E est ajouté à E. Le sommet
sélectionné est le sommet qui peut diminuer le plus le coût de coupe entre E et le reste de G.
Autrement dit, c’est le sommet qui a le gain de la fonction objectif le plus grande. Le processus
s’arrête si le poids de l’ensemble E est égal la moitié du poids total des sommets de graphe.
Cette méthode est très simple et la qualité de la partition obtenue dépend principalement du
sommet de l’initialisation. Pour obtenir de meilleur résultat, on peut lancer le programme avec des
sommets de l’initialisation différents.
Algorithme de GGGP
Procédure GGGP (G = (S, A))
Prendre au hasard une sommet s0 R
E  {s0}
F  {s  R tel que (s, s0)  A }
Calculer les gains de F
Tant que poids(E) < ½ poids(S) faire
Prendre le sommet si F de gain maximal
Déplacer si de F vers E
Pour toute arête (s, si) dans A faire
si s  F alors

Page 13


mettre à jour le gain de s

sinon si s  E alors
ajouter s à F
calculer le gain de s
fin si
fin pour
fin tant que
retourner E
fin Procédure

Méthode spectrale
L’utilisation de la méthode spectrale pour résoudre les problèmes de partitionnement de graphe est
très ancienne. Les premiers articles sont proposés depuis les années 70s par W.Donath et A.Hoffman
(8). Cette méthode est basée au théorème spectral de l’algèbre linéaire. Ce théorème permet
d’affirmer la diagonalisation des matrices réelles. Il justifie également la décomposition des matrices
symétriques réelles en valeurs propres dans une base ortho normale de vecteurs propres. Le
problème de partitionnement de graphe peut être ramené à la résolution d’un système numérique
Mx = x. Résoudre ce système numérique consiste à trouver une base orthogonale de vecteurs
propres de la matrice M.

Algorithme de Kernighan-Lin
L’algorithme de Kernighan-Lin(9) n’est pas exactement une méthode de partitionnement mais plutôt
une méthode d’affiner une bissection d’un graphe précédemment obtenu. L’idée principale de cet
algorithme est de trouver deux sous-ensembles de sommets de même taille, chacun dans une partie
de la bissection, tels que leur échange diminue le coût de coupe de la bissection. A partir d’une
bissection existante, l’algorithme échange successivement deux sous-ensembles de la bissection
jusqu’à on ne peut pas diminuer le coût de coupe. La dernière bissection obtenue est la bissection de
coût de coup minimal trouvé par l’algorithme.
L’algorithme de Kernighan-Lin est d’autant plus rapide et performant si sa partition initiale est de
bonne qualité. En effet, si la partition initiale est de bonne qualité, le nombre d’itérations de
l’algorithme sera petit car il sera rapidement impossible de trouver des sous-ensembles à échange.

De plus, l’optimisation trouvée est locale. Ainsi, pour avoir un coût de coupe minimal, il est préférable
de partir d’une bissection de coût de coupe faible. On peut utiliser la méthode de GGGP pour créer la
bissection initiale.

Page 14


Figure 2. L'idée principale de l’algorithme Kernighan-Lin(5)

Méthode Multi-niveaux
La méthode multi-niveaux a été parallèlement utilisée pour la première fois par Stephen Barnard et
Horst Simon (10)et par Thang Bui et Curt Jones(11) en 1993. La méthode multi-niveaux est plutôt une
stratégie « global » utilisant des algorithmes locaux de partitionnement de graphe. L’idée principale
de cette méthode est de regrouper les sommets ensemble pour traiter de groupes de sommets
plutôt que de sommets indépendants. La méthode multi-niveaux se décompose en trois phases :

Page 15


Figure 3. Schéma de méthode Multi-niveaux

Contraction :Le graphe G0 est transformé en une suite de petits graphiques G1, G2, ..Gm pour que
|V0|>|V1|>...>|Vm|
Partitionnement : Création d’une partition Pm de graphe Gm
Affinage : Les partitions Pi est projeté sur les graphes Gi. Chaque partition Pi est affinée en utilisant un
algorithme local d’affinage.
Cette méthode est générale et son efficacité dépend fortement des méthodes utilisées par les
fonctions « contraction », « partitionnement » et « affinage ». De nombreuses méthodes sont
utilisées pour réaliser ces trois fonctions. Parce que la méthode de multi-niveaux est très
performante pour résoudre les problèmes de partitionnement de graphe, elle a progressivement

remplacé l’utilisation des méthodes spectrales.

Page 16


Figure 4. Comparaison entre des méthodes classiques de partitionnement du graphe (5)

2. 2. Méthodes de métaheuristiques
Les métaheuristiques sont proposées dans les années 1980 pour résoudre des problèmes
d’optimisation difficiles pour lesquelles on ne connaît pas de méthode classique plus efficace.
Le principe de base d’une métaheuristique est de parcourir l’espace des solutions à la recherche de
son minimum global en utilisant des mécanismes pour éviter des minima locaux. Les
métaheuristiques peuvent être classées en deux approches : approche de voisinage et approche à
base de population(12). Les métaheuristiques de voisinage acceptent des solutions dégradées pour
s’extraire des minima locaux tandis que les métaheuristiques de population utilisent un mécanisme
collectif pour se sortir des minima locaux.
Ce chapitre présent le principale de 4 métaheuristiques : deux de voisinage (le recuit simulé et la
recherche taboue) et deux à base de population (l’algorithme de colonies de fourmis et l’algorithme
évolutionnaire).
Pour ce stage, nous n’utilisons que l’approche de voisinage et surtout les algorithmes de recherche
locale : la recherche taboue et le recuit simulé.

Le recuit simulé

Page 17


Le recuit simulé est une métaheuristique inspirée d'un processus utilisé en métallurgie. Elle a
présentée pour le première fois par S.Kirkpatrick, C.Gelatt et M.Vecchi dans (13). Ce processus
alterne des cycles de refroidissement lent et de réchauffage (recuit) qui tendent à minimiser l'énergie

du matériau.
Son principe est simple: à partir d’un état initial, un nouvel état est créé basé sur l’état précédent par
une modification élémentaire de cet état. Il est accepté si son énergie est plus faible, sinon il est
accepté avec une certaine probabilité. Cette probabilité est basée à la température, paramètre
essentiel de contrôle. Au début, la température est haute et l’algorithme accepte plus des mouvais
état pour éviter la minima locaux. De temps en temps, la température est diminuée et l’équilibre est
atteint.

La recherche Taboue
L'idée de la recherche taboue consiste, à partir d'une position donnée, il explore le voisinage et à
choisir la position dans ce voisinage qui minimise la fonction objectif(12). On peut cependant tomber
dans un minima local à l’étape suivante. Pour s’extraire des minima locaux, la recherche Taboue
utilise le mémoire pour interdire de revenir sur les dernières positions explorées.
Les positions déjà explorées sont conservées dans une liste taboue. Cette pile doit conserver des
positions complètes, ce qui dans certains types de problèmes, peut nécessiter l'archivage d'une
grande quantité d'informations. Cette difficulté peut être contournée en ne gardant en mémoire que
les mouvements précédents, associés à la valeur de la fonction à minimiser.

Algorithme de colonies de fourmis
L’algorithme de colonies de fourmis simule la recherche de nourriture des fourmis. Cette idée a été
présentée première fois par A.Colorni, M.Dorigo et V.Maniezzo (14). Une fourmi pose de la
phéromone quand il se déplace. Les fourmis se dirigent de manière probabiliste en comptant de la
quantité de phéromone qui est autour d’elles. Plus la quantité de phéromone indiquant un chemin
est grand, plus des fourmis a tendance à suivre ce chemin. Comme la phéromone s’évapore
progressivement, le choix probabiliste que prend une fourmi pour choisir son chemin évolue
continuellement. Grâce à l’utilisation de phéromone, les fourmis peuvent collectivement trouver le
plus court chemin entre deux points. L’algorithme de colonies de fourmis est bien utilisé à nombre de
problèmes d’optimisation et elle est adaptée pour le problème de partitionnement de graphe dans
les années récemment.

Algorithme évolutionnaire
L’algorithme évolutionnaire s’inspire du principe de sélection naturelle de Charles Darwin. La théorie
de la sélection naturelle s’applique aux individus d’une population et repose sur trois principes (12):


La variation : les individus diffèrent les uns des autres

Page 18





L’adaptation : les individus les mieux adaptés à leur environnement vivent plus longtemps et
procréent plus
L’hérédité : les caractéristiques des individus sont héréditaires.

Le principe de la sélection naturelle est le suivant : Les mieux individus vont plus créer, ses
caractéristiques avantageuses seront héritées par les générations suivantes et avec le temps,
deviendront dominantes dans la population.
Il existe plusieurs adaptations des algorithmes évolutionnaires au partitionnement de graphe. Au
contraire de consumer beaucoup de calcul, les algorithmes évolutionnaires peuvent donner des
résultats très bien. Le logiciel JOSTLE (3) est un exemple.

Page 19


3
Recherche locale et Comet
3. 1. Recherche locale

Définition
Un algorithme de recherche locale démarre d’un état initial et se déplace d’un état courant à un état
voisin dans le but d’améliorer la valeur d’une fonction f. Cette fonction mesure la qualité des états du
problème. Dans des problèmes de satisfaisabilité, cette fonction fournit une distance de l’état
courant à une solution. Il faut alors minimiser la valeur de cette fonction. Dans des problèmes
d’optimisation, la fonction f exprime alors l’objectif du problème qui faut soit maximiser, soit
minimiser. Certains de ces voisins peuvent être légaux. Une fois que les états voisins légaux sont
identifiés, il faut en sélectionner un et ensuite décider de se déplacer à cet état (on effectue alors un
déplacement local) ou de rester à l’état courant (15).
Partitionnement du graphe est un problème d’optimisation et le but est de minimiser la fonction f
qui exprime le coût de coup.
Les notions dans la recherche locale:

 Etat initial : La solution initiale est générée par une heuristique ou méta-heuristique
gloutonne, ou bien par hasard. Un bon choix de la solution initial peut améliorer le résultat
final.


Voisinage : Un état voisin est généré par une modification d’état précédent. Dans la
recherche locale, la définition des voisinages est très importante.



Etat courant et l’espace de recherche : C’est un ensemble des solutions faisable.
Déplacement local : L’échange de l’état au courant à un état voisinage.



Algorithme générique de recherche locale

Page 20


Le code ci-dessous présente l’algorithme générique de recherche locale. L’algorithme démarre avec
un état initial s passé en paramètre et exécute un certain nombre d’itérations. Le déplacement local
consiste à la sélection d’un nouvel état courant parmi les états voisins légaux
Algorithme générique de recherche locale (16)
Procédure RechercheLocale(f, N, L, S, s)
s*  s
pour k = 1 à max_Itération faire
Si satisfaisable(s) & f(s) < f(s*) faire
s*  s
s  S(L(N(s), s), s) ;
retourner s* ;
fin pour
fin Procédure
f : fonction d’objective
N(s) : ensemble des états voisins de l’état courant s (cet ensemble est appelé le voisinage de s)
L(N(s), s) : ensemble des états légaux pouvant être sélectionnés parmi les états voisins
S(L(N(s), s), s) : état sélectionné parmi les états légaux pour effectuer le déplacement local
Il existe plusieurs méthodes pour choisir quels voisins sont légaux et lesquels ne le sont pas, ainsi que
pour sélectionner l’état vers lequel on effectue le déplacement.
Les algorithmes de recherche locale ont deux avantages principaux :



Ils utilisent peu de mémoire (pas de chemin et alternative à retenir)
Ils trouvent souvent des solutions raisonnables dans de grands espaces de recherche, pour
lesquels certains algorithmes de recherche systématique ne conviennent pas

Les algorithmes de recherche locale sont utiles pour résoudre des problèmes d’optimisation, dans
lesquels le but est de trouver le meilleur état compte tenu d’une fonction objectif, dont il faut
maximiser ou minimiser la valeur. Dans la figure au-dessous, la courbe représente les différents états
d’un problème. Le but dans ce cas est de trouver l’état qui minimiser la valeur de la fonction objectif,
appelé minimum global. Certains algorithmes, par exemple, le Hill-Climbing Search restent coincés à
un minimum local. Souvent, un optimum local est un état qui correspond à une solution raisonnable
du problème, mais pas optimale. La grande difficulté des algorithmes de recherche locale est de
s’extraire à ces optima locaux et de se diriger le plus rapidement vers l’optimum global.

Page 21


Figure 5. Représentation de l'espace de recherche de recherche locale

3. 2. Le langage Comet
Introduction
COMET (17) est un langage orienté objet qui supporte les abstractions de modélisation et de
recherche pour la programmation par contraintes. Les abstractions de modélisation présentent des
invariants et un riche langage de contraintes, qui incluent des contraintes numériques, logiques et
combinatoires. Les abstractions de recherche incluent des sélecteurs aléatoires et des structures de
contrôle pour assurer le non-déterminisme. De plus, COMET est un langage ouvert : les
programmeurs peuvent ajouter leurs propres contraintes et objectifs, ainsi que leur propres
abstractions de contrôle. COMET est disponible en plusieurs plateformes : Linux, Windows, Mac OS,..

Architecture de COMET
Dans COMET, les algorithmes de recherche locale peuvent être spécifiés en terme de composants de
modélisation et de recherche
Recherche Locale = Modèle + Recherche
L’architecture de COMET est schématisée par la figure au-dessous. Elle est organisé en trois couches :
les invariants, les objets différentiables et le composant de recherche

Page 22


Figure 6. Architecture de COMET(16)



Les invariants

Le noyau de l’architecture est le concept d’invariants. Ils sont exprimés en termes de variables
incrémentales et spécifient une relation qui doit toujours être maintenue.
Par exemple: var {int} s(m)  sum (i in 1..10) a[i];
déclare une variable incrémentale s de type entier. L’invariant spécifie que s est toujours la somme
des éléments de a. Si une nouvelle valeur est assignée à a*i+, la valeur de s est mise à jour
automatiquement en un temps constant. COMET supporte des invariant algébriques, d’ensemble et
de graphe. Les invariants sont tenus à jours par COMET chaque fois qu’une assignation de nouvelles
valeurs se produit sur les variables d’un invariant.


Les différentiables

Les objets différentiables maintiennent des propriétés et peuvent être interrogés pour évaluer l’effet
d’un déplacement local sur leurs propriétés en utilisant des invariants. Les objets différentiables sont
classées en deux types : les contraints et les objectifs. Les contraints maintiennent des propriétés
telles que leur satisfaisabilité, leur violations et combien de ses variables associées contribuent à la
violation tandis que les objectifs maintiennent la valeur d’une fonction et une évaluation qui peut
être utilisée pour différencier deux états ayant la même valeur. Les objectifs peuvent être
questionnés pour estimer la variation de leur valeur lors de déplacement locaux.
Par exemple, la méthode getSwapDelta(v, w) renvoie la variation du degré de violation quand les

valeurs des variables v et w sont échangés.


Le composant de recherche

Tandis que les deux premières couches sont pour but à la modélisation des algorithmes de recherche
locale, le composant de recherche propose des abstractions et des constructeurs de haut niveau pour
simplifier l’exploration du voisinage d’un état et l’implémentation de métaheuristiques.

Page 23


Avantages de COMET
Le composant de modélisation exprime la structure combinatoire de l’application en termes de
contraintes et d’objectifs. Les problèmes sont décrits dans une manière déclarative de haut niveau.
Le composant de recherche exploite la structure définie dans le modèle pour guider l’exploration
dans l’espace de recherche vers une solution de haute qualité. COMET support des abstractions telles
que des sélecteurs pour faciliter la formulation des heuristiques (par exemple pour choisir un état
voisin).
Les deux composants sont physiquement séparés dans le code COMET. Le modèle et la recherche
peuvent évoluer chacun de leur côté : la procédure de recherche peut-être remplacée par une autre
sans affecter le modèle et, inversement, le modèle peut-être amélioré sans devoir modifier la
procédure de recherche.
COMET est un langage de recherche riche pour la recherche locale et nous choisissions COMET pour
les implémentations des algorithmes de recherche locale pour le problème de partitionnement du
graphe (Recherche Tabou et Recherche de Recuit Simulé)

Page 24

4
Méthode de Multi Niveaux
4. 1. Principale
La principale de la méthode de multi niveaux est de créer rapidement une partition d’un graphe
G(S,A) de grande taille par regrouper les sommets ensemble. En effet, elle s’occupe aux groupes de
sommets plutôt que les sommets indépendants. La méthode multi-niveaux se décompose en trois
phases sur le graphe G : la contraction, le partitionnement et l’affinage.
Algorithme multi-niveaux pour le partitionnement de graphe (18)
Procédure MultiLevel (G,k)
G1 = G
i=1
Répète
ii+1
Gi = contraction (Gi-1)
jusqu’à ce que contraction faible ou Gi+1 suffisamment petit
𝑃𝑘𝑖 = partitionner (Gi, k)
pour j = i – 1 à 1 faire
𝑗 +1
Pk = projection(𝑃𝑘 , Gj)
𝑗
𝑃𝑘 = affinage(Pk)
fin pour
returner𝑃𝑘1
fin Procédure

4. 2. Contraction
A chaque itération, les sommets sont regroupés pour former un graphe similaire, mais le nombre de
sommets de nouveau graphe est plus petit que le précédent. Ainsi, pendant cette phase, une
séquence des plus petits graphs ,G1, G2, ...Gm} sont créées.

Page 25