=
où (l s) est une branche de feuille l (le littéral à effacer), B un arbre et p la clause en
production, alors l’étape suivante a l’une des forme C1 ou C2.
C1. On met en production le littéral l si l’étape suivante est :
C2. On effectue une résolution si l’étape suivante est :
où les littéraux l’i
sont tels que les conditions de C2a et de C2b sont vérifiées.
C2a. Il existe une clause c’ de C, la clause appelée à cette étape,
- qui contient l’opposé de l,
- dont aucun littéral n’est dans la branche (l s) (les littéraux de cette branche sont
les ascendants ou a-ancêtres)
- dont aucun littéral n’a pour opposé une feuille de l’arbre B (les frères de l)
- dont aucun littéral n’a pour opposé un littéral de la clause en production p (les
littéraux de cette clause sont les littéraux en production).
Les trois dernières conditions sont les conditions de non répétition.
C2b. Les l’i sont alors les littéraux de cette clause c’, qui ne sont pas
immédiatement effaçables, c’est à dire ceux :
- dont l’opposé n’est pas dans la branche (l s),
- qui ne sont pas égaux à une feuille de l’arbre B,
- qui ne sont pas égaux à un littéral de la clause en production.
2.2.2. Exemple d’utilisation
Soit l’ensemble C de cinq clauses : 42 Conclusion conséquente et la production
¬a b c
¬b d e
f e ¬a ¬d c
¬c e f
¬e f g
L’ensemble C ⋃ {a f} implique la clause f g et C ne l’implique pas. Il existe donc au
moins une production d’origine a f qui produit f g. C’est par exemple le cas de :
1. <0 ,(a) (f)>
2. ¬a b c <0 ,(ba) (ca) (f)>
3. ¬b d e <0 ,(dba) (eba) (ca) (f)>
4. f e ¬a ¬d c <0 ,(eba) (ca) (f)>
5. ¬e f g <0 ,(geba) (ca) (f)>
6.
7. ¬c e f
8. ¬e f g
9.
Pour visualiser globalement toutes les étapes d’une production, il est possible de faire un
dessin du type :
Figure 2.3. Les étapes d’une production
2.3. Champ de production
La notion de champ de production dépassant le cadre restreint du calcul propositionnel,
cette partie en donnera la définition dans le cadre général du calcul des prédicats. Une
« formule » sera donc ici une formule de la logique du premier ordre et, bien entendu, une
« formule propositionnelle » une formule du calcul propositionnel.
2.3.1. DéfinitionConclusion conséquente et la production 43
Définition 2.10:
Un champ de production P est un ensemble de formules dont chacune est un résultat
possible dont on a besoin de savoir s’il est vrai ou non dans un certain état de connaissance.
Le but du jeu est de trouver les formules de cet ensemble vraies pour une connaissance
donnée. Il s’agit donc d’une notion assez naturelle qui pourra se définir, correctement d’un
point de vue logique, de manière simple.
De manière très générale, deux problèmes se posent :
Problème 2.1:
Soit :
- L un langage du premier ordre,
- P un ensemble de formules de L, le champ de production,
- C un ensemble de formules de L, la connaissance,
Trouver l’ensemble, produites(C, P), des formules sémantiquement impliquées par C et
appartenant à P.
Si th(C) représente toutes les formules sémantiquement impliquées par C, on a donc :
produites(C, P) = th(C) ∩ P
Problème 2.2:
Soit :
- L, P, C définis comme précédemment,
- C’ un nouvel ensemble de formules de L, la nouvelle connaissance,
Trouver toutes les formules de P impliquées par C ⋃ C’, qui appartiennent à P et qui ne
sont pas impliquées par C.
Cet ensemble des formules se notera nouv-prod(C’, C, P) :
nouv-prod(C’, C, P) = produites(C ⋃ C’, P) – produites(C, P).
Définition 2.11:
Si c1 et c2 sont des clauses, on dira que c1 est une sous clause de c2, ou que c1 subsume c2
si tout littéral de c1 est un littéral de c2. On dira également que c1 subsume strictement de c2
(est une sous clause stricte) si c1 subsume c2 et c2 ne subsume pas c1.
Si F est un ensemble de formules qui ne sont pas des tautologies, et G un sous ensemble
de F, on dit que :
- G est un précurseur de F si toute formule de F est impliquée par une formule de G.
« Pour toute f dans F il existe g dans G telle que g ⊨ f » 44 Conclusion conséquente et la production
- G est un plus petit précurseur de F (ou précurseur minimal de F), si de plus aucune
formule de G n’implique une autre formule de G. « Si G est un précurseur de F, et si g1 et g2
sont dans G et g1 ⊨ g2 alors g1 = g2 ».
Propriété 2.1:
Si G1 et G2 sont deux précurseurs minimaux de F, il existe une bijection bij de G1 dans G2
telle que, pour toute formule g1 de G1, il existe un unique g2 de G2 tel que g1 et bij(g2) sont
logiquement équivalentes.
Définition 2.12:
Un champ de production P est stable pour l’implication sémantique si toute formule qui
implique sémantiquement une formule de P est dans P.
Propriété 2.2:
Si P est un ensemble de clauses propositionnelles, alors P est stable si et seulement si
toute sous clause d’une clause de P est dans P.
2.3.2. Exemple d’utilisation
Si L est un langage propositionnel contenant une infinité de propositions p1, p2, ..., et si la
connaissance est un ensemble de deux clauses :
C = ¬p1⋁p2⋁p3 ‘si p1, alors p2 ou p3 est vrai’
p1 ‘p1 est vrai’
Si le champ de production est l’ensemble des clauses de L ne contenant que des littéraux
positifs (clauses positives), on a :
produites(C, P) = p1 ‘p1 est vrai’
p2⋁p3 ‘p2 ou p3 est vrai’
Si maintenant la nouvelle connaissance se compose des deux unaires :
C’ = p4 ‘p4 est vrai’
¬p3 ‘p3 est faux’
alors on obtient :
nouv-prod(C’, C, P) = p4 ‘p4 est vrai’
p2 ‘p2 est vrai’Conclusion conséquente et la production 45
2.4. Algorithmes de calcul de production
2.4.1. Description simplifiée
Notre problème pratique est dont de calculer toutes les clauses impliquées par un
ensemble fini C de clauses et appartenant à un champ de production P. Comme P est en
général très grand, il est évident que la technique consistant à vérifier, pour toute clause de P,
si elle est impliquée par C ou non, est totalement inapplicable. Cette partie va étudier un
algorithme basé sur la SOL résolution qui essaie de résoudre partiellement ce problème.
Pour bien faire son travail, il doit s’arrêter, ne donner que des résultats corrects et donner
tous les résultats. On s’assure de ceci en démontrant trois propriétés.
Propriété 2.3:
Un ensemble fini de clauses a un ensemble fini de productions (l’algorithme s’arrête).
Propriété 2.4:
Toute clause produite par une production de C est impliquée par C (les résultats sont
valides).
En particulier, si une production de C produit la clause vide, alors C est inconsistant.
Propriété 2.5:
Si une clause d est impliquée par C, il existe une production de C dont la clause produite
subsume d (les résultats sont tous trouvés).
En particulier, si C est inconsistant, il existe une production de C qui produit la clause
vide.
Propriété 2.6:
Si C n’implique pas d et C ⋃ {c} implique d, il existe une production de C ⋃ {c},
d’origine c dont la clause produite subsume d.
En particulier, si C ⋃ {c} est inconsistant, et C ne l’est pas, il existe une production de C
d’origine c qui produit la clause vide.
Il faut maintenant décrire l’algorithme qui génère toutes les clauses impliquées par un
ensemble C de clauses et appartenant à un champ de production P. Cet algorithme a été
implanté en SWI Prolog. Les clauses, branches et arbres sont représentés classiquement :
- un littéral x s’écrira plus(x) s’il est positif et moins(x) s’il est négatif.
- une liste de littéraux (clause ou branche) se notera de la manière habituelle l1. l2... ln.
nil où nil représentant la liste vide.
- un arbre est une liste s1. s2... sm. nil de branches. Les si sont donc des listes non vides
de littéraux (donc différentes de nil).
- un ensemble de clauses est identifié à une liste c1. c2... cp. nil de clauses.46 Conclusion conséquente et la production
Description simplifiée :
Pour produire les clauses impliquées par une liste C = c. C’ (c est une clause et C’ une
liste de clauses éventuellement vide) appartenant à un champ de production P, il faut produire
les clauses impliquées par C’ puis produire les clauses impliquées par c.C’ et non par C’. Pour
ce faire on utilise le prédicat grande-production :
grande-production(nil, P) → ;
grande-production(c.C, P) →
grande-production(C, P)
construire-arbre(c, nil, nil, nil, A)
production(nil, A, C, P) ;
Le cœur de l’algorithme est la définition d’un prédicat à quatre arguments production(p,
A, C, P), où p est la clause en production, A un arbre, C l’ensemble de clauses et P le champ
de production. L’arbre A origine est donné par le prédicat construire-arbre, qui transforme la
clause origine
c = l1. l2... ln. nil
en un arbre dont les branches sont composées d’un littéral de cette clause :
A = (l1.nil).(l2.nil) .... (ln. nil).nil
On définit production par trois clauses Prolog :
(1) production(p, nil, C, P) →
utiliser(p) ;
(2) production(p, (l.s).B, C, P) → /* Forme C2*/
dans(c’, C) /* Prendre une clause c’ de C */
bonne-clause(c’, p, (l.s).B) /* Conditions C2a */
construire-arbre(c’, p, (l.s).B, B’) /* Construire l’arbre B’ à partir de la
clause c’, conditions C2b*/
production(p, B’, C, P) ;
(3) production(p, (l.s).B, C, P) → /* Forme C1*/
bon-debut-de-clause(l.p, P) /* l .p satisfaisante le champ de
production P*/
production(l.p, B, C, P) ;
dans(x, x.r) → ;
dans(x, y.r) → dans(x,r) ;
La clause (1) est le cas terminal d’une production. Ici, on l’ajoutera sous de forme d’une
clause Prolog : clause-produite(p) → ;
utiliser(p) → assert(clause-produite(p), nil) ;Conclusion conséquente et la production 47
Pour être en accord avec la définition, bonne-clause doit vérifier les conditions de non
répétition. Il faut donc :
1- S’assurer que l’opposé de la feuille de la première branche de l’arbre est bien dans la
clause candidate.
2- Vérifier que tous les littéraux de cette clause :
- ne sont pas dans la première l.s de l’arbre,
- n’ont pas leur opposé dans la clause en production p,
- n’ont pas leur opposé égal à une feuille de l’arbre B.
Ceci s’effectue de manière naturelle :
bonne-clause(c’, p, (l.s).B) →
oppose(l, l’)
dans(l’, c’)
bons-littéraux(c’, p, (l.s), B)
bons-littéraux(nil, p, A) → ;
bons-littéraux(l.r, p, s.B) →
bons-littéraux(r, p, s.B)
pas-dans(l, s)
oppose(l, l’)
pas-dans(l’, p)
pas-dans-feuilles(l’, B) ;
oppose(plus(x), moins(x)) → ;
oppose(moins(x), plus(x)) → ;
pas-dans(x, nil) → ;
pas-dans(x, y.r) →
dif(x, y)
pas-dans(x, r) ;
pas-dans-feuilles(x, nil) → ;
pas-dans-feuilles(x, (l.s).B) →
pas-dans(x, l.s)
pas-dans-feuilles(x, B) ; 48 Conclusion conséquente et la production
Il faut maintenant définir construire-arbre qui, à partir de la clause
c’ = l1. l2... ln. nil
de la clause en production p et de l’arbre (l.s).B va construire l’arbre
A’ = (l’1.l.s) ... (l’p.l.s).B
les l’i étant les littéraux de c’ non immédiatement effaçables.
construire-arbre(nil, p, s.B, B) → ;
construire-arbre(l.r, p, s.B, (l.s).B’) → /* Conditions C2a sont vérifiées*/
oppose(l, l’)
pas-dans(l’, s)
pas-dans(l, p)
pas-dans-feuilles(l, B)
/
construire-arbre(r, p, s.B, B’) ;
construire-arbre(l.r, p, A, A’) → /* Conditions C2a ne sont pas vérifiées*/
construire-arbre(r, p, A, A’) ;
Pour vérifier qu’une clause est dans un champ de production défini par une quadruplé de
bases quelconque, on peut écrire :
bon-debut-de-clause(c, P.l-iste-P) →
dans-le-champ(c, P)
/ ;
bon-debut-de-clause(c, P.l-iste-P) →
bon-debut-de-clause(c, l-iste-P) ;
dans-le-champ(l.c, ) →
eq(l, s-igne)
dans(l, a-lpha)
longueur-inferieure(l.c, l-ong)
dans(c’, s-ous-cl)
subsume(c, c’)Conclusion conséquente et la production 49
/ ;
subsume(nil, c) →
/ ;
subsume(l.c’, c) →
subsume(c’, c)
dans(l, c) ;
longueur-inferieure(c, infini) →
/ ;
longueur-inferieure(nil, l) → ;
longueur-inferieure(a.c, l) →
/
impasse ;
longueur-inferieure(a.c, l) →
val(sub(l, l), l’)
longueur-inferieure(c, l’) ;
2.4.2. Algorithme avec coupure
A toute étape de production, on essaie d’effacer le premier littéral de la première branche
d’arbre (le littéral à effacer). Pour ce faire, il faut choisir une clause candidate contenant
l’opposé de ce littéral et satisfaisant aux conditions de non répétition, en ôter tous les littéraux
immédiatement effaçables (qui ne satisfont pas aux conditions C2b), puis essayer d’effacer la
clause restante. Quand tous ces choix ont été effectués et résolus, il reste un choix
supplémentaire qui est de mettre en production le littéral à effacer.
Or, si le littéral à effacer a été, pour un certain choix, complètement effacé sans avoir eu
besoin d’installer des littéraux en productions supplémentaires, il est inutile d’effectuer les
choix restants. On peut formaliser ceci par une définition et une propriété.
Définition 2.13:
S’il existe un début de production, D, de dernière étape (j) :
..............................
(i)
.............................. 50 Conclusion conséquente et la production
(j)
telle que B1 = B2 et p1 = p2, on dira que le littéral l a été complètement effacé.
Propriété 2.7:
Dans ce cas toute production égale à D jusqu’à l’étape (i) incluse, ne pourra produire que
des clauses subsumées par d’autres clauses produites par les productions de début D.
Donc, d’après la structure de l’algorithme, qui à partir de l’étage (i+1), calcule toutes les
productions ayant ces (i) premières étapes avant de faire les autres choix pour l à l’étape
(i+1), il sera inutile si ce littéral est complètement effacé de faire ces autres choix. C’est
principalement pour cette raison que l’on essaie d’abord d’effectuer toutes les résolutions
possibles sur un littéral avant de mettre ce littéral en production (avant d’essayer d’effacer de
manière classique un littéral, on regarde s’il n’existe pas une clause contenant son opposé et
dont tous les littéraux sont immédiatement effaçables). Le choix inverse est possible mais
donne de moins bons résultats.
Démonstration :
Soit PR1 une production égale à D jusqu’à (i). Cette production aura une étape (j’) dont
l’arbre est B1, et peut donc s’écrire :
..............................
(i)
..............................
(j’)
..............................
(n’)
PR1 produit la clause p = r q p1 dans laquelle q et r sont des clauses éventuellement vides
(la notation inclut le cas où j’ = n’). Pour prouver le théorème, il faut construire à partir de
PR1 une production, PR2, dont le début est D et dont la clause produite subsume p.
Le début de PR2 est donc :
..............................
(i)
..............................
(j) Conclusion conséquente et la production 51
L’important est que, à l’étape (j’) de PR1 et à l’étape (j) de PR2, les arbres sont égaux. À
l’étape (j), la clause en production, p1, de PR2 est une sous clause de la clause en production à
l’étape (j’), q p1, de PR1.
Les étapes de PR2 qui suivent (j) sont construites à partir des étapes de PR1 qui suivent
(j’) telles que, si la clause appelée contient un littéral de r q alors ce littéral n’est pas
immédiatement effacé mais inséré dans l’arbre. Il sera mis en production à l’étape où il sera
littéral à effacer de l’arbre courant. Plus précisément :
1. L’étape (j+1) de PR2 est construite à partir de l’étape (j’+1) de PR1 telle que :
- si (j’+1) met en production le littéral à effacer, alors (j+1) mettra également en
production ce même littéral à effacer.
- si (j’+1) effectue une résolution sur une clause c, alors (j+1) effectuera également
une résolution sur cette même clause c. Les branches ajoutées à l’arbre B1 (dans
PR2) sont obtenues à partir des littéraux de c non immédiatement effaçables (dans
PR1). Mais les littéraux de c immédiatement effaçables dans PR2, sont les
littéraux de c immédiatement effaçables dans PR1, plus les littéraux de c, égaux à
un des littéraux de q (les ascendants et frères sont les mêmes dans PR1 et PR2 car
les arbres sont égaux à l’étape (i)). Donc les branches à ajouter dans PR2 sont les
branches à ajouter dans PR1, plus éventuellement un certain nombre de branches
dont les racines sont les littéraux de c qui ne sont pas dans q.
2. On répète l’opération pour les étapes suivantes de PR2, qui sont construites à partir
des étapes de PR1. Les clauses appelées sont les mêmes dans PR1 et PR2. La seule
différence est que dans les arbres correspondants (dans PR2) sont insérées un certain
nombre de branches supplémentaires, branches dont les racines seront toujours des
éléments de q. Quand le littéral à effacer (dans PR2) portera sur une de ces branches
supplémentaires, ce littéral sera mis en production. On insère donc un certain nombre
d’étapes qui sont toutes des mises en production de littéraux de q.
La suite de couples ainsi formée est bien une production, car comme PR1 en est une, on
en déduit que pour toutes les étapes de résolution de PR2 les clauses appelées satisfont aux
conditions de non répétition. En effet, ces étapes sont telles que :
- l’étape associée dans PR1 satisfait aux conditions de non répétition
- les ascendants sont les mêmes dans PR1 et PR2 car ces étapes sont des étapes de
résolution et ne portent donc pas sur les branches supplémentaires (on a dit que les
étapes portant sur les branches supplémentaires mettent en production un littéral).
- l’union des frères et littéraux en production de PR2 est incluse dans l’union des frères et
littéraux en production de PR2.
PR2 est donc bien une production et la clause produite par PR2 subsume bien celle
produite par PR1 car les littéraux mis en production dans PR1 et non dans PR2 sont tous dans
q.
Exemple 2.2:
Soit un ensemble de clause : 52 Conclusion conséquente et la production
C = {a b c, ¬a b, ¬a u, ¬u v, ¬v w}
On veut calculer toutes les productions d’origine a b c. L’algorithme construira, par ses
appels récursifs, la première production qui produit la clause c b :
1. <0 ,(a) (b) (c)>
2. ¬a b <0 ,(b) (c)>
3.
4.
Cette production est donnée par le choix de ¬a b à la deuxième étape. Il reste deux choix
à cette étape : soit appeler la clause ¬a u, soit mettre a en production. En fait ces choix sont
inutiles car ils ne pourront générer que des clauses subsumées par d’autres clauses produites
par la production effectuée auparavant. Le premier choix donne trois productions dont la
première est :
1. <0 ,(a) (b) (c)>
2. ¬a u <0 ,(ua) (b) (c)>
3. ¬u v <0 ,(vua) (b) (c)>
4. ¬v w <0 ,(wvua) (b) (c)>
5.
6.
7.
En fait, c b w est subsumée par c b.
2.4.3. Algorithme en Prolog
Pour produire les clauses d’un champ de production P impliquées par un ensemble C on
appellera comme auparavant grande-production(C, P) :
grande-production(nil, P) → ;
grande-production(c.C, P) →
grande-production(C, P)
production(c, nil, nil, nil, p, C, P)
utiliser(p) ;
production(nil, A, B, p, p, C, P) → ; //le cas terminal
production(l.c, A, B, p1, p3, C, P) →
conc(c, B, B1) // B1=c.B, construire la liste des frères
oppose(l, l’)
dans(c1, C)
dans(l’, c1)
bonne-clause(c1, l.A, B1, p1) // Conditions C2a Conclusion conséquente et la production 53
simplifier-clause(c1, l.A, B1, p1, c2) // Conditions C2b, enlever les littéraux
production(c2, l.A, B1, p1, p2, C, P) //Concaténant aux ascendants le littéral
(p1 == p2 *→ !; true) //couper(p1, p2)
production(c, A, B, p2, p3, C, P) ; //si p1 = p2 ou p1≠ p2
production(l.c, A, B, p1, p3, C, P) → //mettre en production si p1≠ p2
bon-debut-de-clause(l.p1, P)
production(c, A, B, l.p1, p3, C, P) ;
bonne-clause(nil, A, B, p) → ;
bonne-clause(l.c, A, B, p) →
pas-dans(l , A)
oppose(l, l’)
pas-dans(l’, B)
pas-dans(l’, p)
bonne-clause(c, A, B, p) ;
simplifier-clause(nil, A, B, p, nil) → ;
simplifier-clause(l.c, A, B, p, l.c’) →
oppose(l, l’)
pas-dans(l’, A)
pas-dans(l, B)
pas-dans(l, p)
/
simplifier-clause(c, A, B, p, c’) ;
simplifier-clause(l.c, A, B, p, c’) →
simplifier-clause(c, A, B, p, c’) ;
conc(nil, y, y) → ;
conc(a.x, y, a.z) →
conc(x, y, z) ;
Où :
production(clause, ascendants, frères, produit-initiale, produit-finale, ensemble, champ) 54 Conclusion conséquente et la production
- La clause à effacer, clause, est un bout d’une clause de c ∪ C qui contient le premier
littéral (littéral à effacer).
- ascendants est la liste des ascendants de ce premier littéral.
- frères est la liste des frères de ce premier littéral, autres que les littéraux de clause.
- A l’appel de production, produit-initiale donne la clause en production à ce moment.
L’argument produit-finale donne alors la clause en production résultante.
Pour que ces algorithmes travaillent avec les variables, il faut les améliorer. Par exemple,
pour représenter l’idée : a est une protéine et b un substrat ; tous les substrats sont activés par
les protéines, ceci doit être écrit dans la basée de données comme ci-dessous :
proteine(a).
substrat(b).
ecrit :-
proteine(X),
substrat(Y),
assert(clause(active(X,Y))). La logique des défauts 55
Chapitre 3. La logique des défauts
3.1. Introduction
Quand un algorithme d’Intelligence Artificielle doit résoudre un problème, il peut être en
mesure de s'appuyer sur des informations complètes. Sa tâche principale est alors de donner
de bonnes conclusions par un raisonnement classique. Dans ce cas, la logique des prédicats
peut être suffisante.
Cependant, souvent l’information est incomplète, car certaines informations ne sont pas
disponibles. Parfois, il peut aussi être nécessaire de répondre rapidement et il est alors
impossible de recueillir toutes les données pertinentes en un temps raisonnable. Dans ce cas,
le système doit faire des conjectures plausibles, c’est la problématique des logiques nonmonotones
[7,9]. Pour la logique des défauts ces conjectures sont basées sur des règles
empiriques, appelées défauts. Par exemple, un médecin d’urgence doit faire des conjectures
sur les causes les plus probables des symptômes observés et il est impossible d'attendre le
résultat de tests éventuellement étendus et chronophages avant le début du traitement.
Lorsque les décisions sont fondées sur des hypothèses, elles peuvent se révéler fausses
face à de nouvelles informations qui seront disponibles [13]. Par exemple les examens
médicaux peuvent conduire à un diagnostic modifié. Il faut alors ajouter de nouvelles
informations qui peuvent être contradictoires, avec les conclusions (le diagnostic) précédent.
Cet ajout est impossible en logique classique, qui a la propriété de monotonie. Intuitivement
cette propriété dit que si une conclusion C est déductible d’un ensemble de prémices P1, et
que l’on ajoute des informations P2 à P1, alors C est démontrable de P1 et P2. Dans le cas de la
logique du premier ordre P1, P2 et C sont des ensembles de formule et la propriété de
monotonie s’écrit :
P1 ⊢ C ⇒ P1 ⋃ P2 ⊢ C
Si cette propriété n’est pas vérifiée, alors on a une logique non-monotone. La logique des
défauts présentée par Reiter en 1980 est une des premières logiques non-monotones. Elle est
très intéressante, car simple à comprendre et à utiliser.
3.2. Notion de défaut
La logique des défauts définie par Reiter formalise le raisonnement par défaut. Elle
permet de traiter les règles admettant des exceptions sans être obligé de remettre en cause les
règles précédemment établies à chaque fois qu'une nouvelle exception apparaît. Une théorie
des défauts est un couple {W, D} où W est un ensemble de formules classiques de la logique
du premier ordre et D un ensemble de défauts, qui sont des règles d'inférence spécifiques. Les
défauts permettent de gérer les informations incomplètes [8].
Par exemple, en hiver, une règle générale utilisée par les arbitres de football pourrait être :
«Un match de football doit avoir lieu, à moins qu’il n’y ait de la neige sur le stade ». Cette
règle de base est représentée par un défaut : 56 La logique des défauts
��������: ¬�����
�����_����
L’interprétation du défaut est la suivante : si on n’a pas l’information explicite qu'il y aura
de la neige dans le stade, il est raisonnable de supposer qu’il n’y aura pas de neige (¬neige) et
de conclure que le match aura lieu. On peut donc préparer le match. Mais s’il y a une forte
chute de neige pendant la nuit avant le match, cette hypothèse n’est plus valide. On sait qu'il y
a de la neige, et il est donc impossible d’assumer ¬neige, donc le défaut ne peut pas être
appliqué. Dans ce cas, il faut renoncer à la conclusion précédente (le match aura lieu). Le
raisonnement est donc non-monotone.
La logique classique n’est pas appropriée pour modéliser cette situation. En effet, on
pourrait tenter d’utiliser la formule
football ∧ ¬neige → avoir_lieu
Le problème avec cette règle, c'est qu’il faut établir de façon définitive qu'il n'y aura pas
de neige dans le stade avant d'appliquer la règle.
Pour résoudre ce problème, le même exemple aurait pu être représenté par le défaut
��������: �����_����
�����_����
avec la règle de logique classique
neige → ¬avoir_lieu.
Si la neige est certaine alors on déduit ¬avoir_lieu par la logique classique, donc on ne
peut pas inférer avoir_lieu par le défaut. Dans cette représentation, le défaut est une règle qui
dit que les matchs se déroulent généralement et les exceptions de cette règle sont représentées
par les règles classiques telles que celle ci-dessus.
Les défauts peuvent être utilisés pour modéliser le raisonnement prototypique, ce qui
signifie que la plupart des instances d’un concept ont une certaine propriété. Un exemple est
l’énoncé « Typiquement, l’enfant a des parents (vivants) », qui peut être exprimé par le
défaut :
������(�): �����_�������(�)
�����_�������(�)
Une autre forme de raisonnement par défaut est le raisonnement sans-risque. Il s'agit de
situations où une conclusion peut être tirée, même si ce n'est pas le plus probable, car une
autre décision peut conduire à une catastrophe. Par exemple « En l'absence de preuve
contraire présumer que l'accusé est innocent, s’exprime par :
�����é(�): ��������(�)
��������(�)La logique des défauts 57
On donne aussi des hiérarchies avec des exceptions qui sont en biologie. L’exemple
classique est « En règle générale, les oiseaux volent », « les manchots sont les oiseaux », « les
manchots ne volent pas ». On a alors le défaut:
������(�): ����(�)
����(�)
avec la règle de logique classique :
manchot(X) → oiseau(X)∧¬vole(X)
Les défauts peuvent être aussi utilisés pour modéliser l’hypothèse du monde clos de
Reiter, utilisée pour les bases de données et pour la programmation logique. Selon cette
hypothèse, un domaine d’application est décrit par un ensemble de formules logiques F. En
simplifiant, l’hypothèse du monde clos dit qu’une information élémentaire positive (un
atome) ϕ est considéré comme faux si F n’implique pas logiquement ϕ. Ceci peut se
représenter par un défaut normal sans prérequis :
����: ¬ϕ
¬ϕ
On encore, s’il est consistant d’assumer ¬ϕ (ce qui est équivalent à ne pas avoir de preuve
pour ϕ), on conclue ¬ϕ
3.3. Syntaxe de la logique des défauts.
Une théorie des défauts ∆ = (D, W) est une paire (D, W), contenant un ensemble W de
formules de la logique des prédicats (appelées faits ou axiomes) et un ensemble dénombrable
D de défauts. Dans sa forme la plus générale, un défaut d s’écrit :
� =
�:�1,�2, … ��
�
où A, B1,…, Bn et C sont des formules logiques bien formées du premier ordre. La formule A
est le prérequis, les formules B1,…, Bn sont les justifications et C est le conséquent.
Un défaut signifie informellement : si A est vérifié, et s’il est possible que B1,…, Bn soient
vrais alors C est inféré.
Un défaut d est appelé normal si et seulement si sa justification est égale à son prérequis,
donc s’il est de la forme :
� =
�: �
�
Un défaut peut contenir des variables libres, par exemple :
������(�): ����(�)
����(�)58 La logique des défauts
Ces défauts sont appelés défauts ouverts. Dans ce cas le défaut ouvert est considéré
comme l’ensemble des défauts où X a été remplacée par tous les termes terminaux (sans
variables) du langage. Un défaut ouvert représente donc un ensemble de défauts fermés qui
peut éventuellement être infini.
3.4. Extensions.
L'utilisation des défauts augmente le nombre de formules déduites de la base de
connaissance W : nous obtenons alors des extensions qui sont des ensembles de théorèmes
dérivables de façon monotone. Intuitivement une extension est obtenue en utilisant un
ensemble maximal consistant de défauts possibles. Cette définition va entrainer qu’il pourra
exister plusieurs extensions éventuellement contradictoires.
3.4.1. Extensions - définition formelle.
Une extension de la théorie des défauts ∆ = (D,W) est un ensemble E de formules, clos
pour la déduction, contenant W et vérifiant la propriété suivante : si d est un défaut de D dont
le prérequis est dans E, sans que la négation de sa justification soit dans E, alors le conséquent
de d est dans E. Plus formellement, les extensions sont définies de la façon suivante.
Définition 3.1: E est une extension de ∆ si et seulement si � = ⋃�=0,∞ ��
, avec :
1) E0
= W
2) Pour tout i, ��+1 = �ℎ(�� ∪ {�/� = (�:�
�
) ∈ �, � ∈ ��
, ¬�∉�})
où Th(F) désigne l'ensemble des théorèmes obtenus en logique classique à partir de F,
c’est à dire Th(F) = {w/F ⊢ w}.
Remarque : Il est important de noter que E apparaît dans la définition de Ei+1. Donc dans
le cas général il peut ne pas être possible de construire E car à cause de la condition ¬B ∉ E,
il faut déjà connaître E pour construire E. La définition n’est donc pas constructive. Ceci peut
être très gênant mais si l’on utilise uniquement des défauts normaux, la condition ¬B ∉ E se
transforme en ¬B ∉ Ei
. Cette fois, il suffit de vérifier que la négation de la justification
n'appartient pas à Ei
. Un algorithme récursif peut donc être utilisé pour calculer E. De plus
lorsque tous les défauts sont normaux et que W est satisfaisable, l'existence d'au moins une
extension est assurée.
Exemple 3.1: Soit ∆ = (D, W), où W = {a}, et D contient les défauts normaux
suivants :
�1 =
�:¬�
¬�
�2 =
�: �
�La logique des défauts 59
On obtient avec la définition des extensions une extension E = Th({a, ¬b}) en utilisant le
défaut d1. Dans ce cas d2 ne pas être utilisé car comme ¬b ∈ E, la justification de d2 n’est pas
vérifiée.
Exemple 3.2: C’est l’exemple classique. On sait que Les manchots sont des oiseaux
et que Titi est un manchot. Ceci va s’exprimer par W composé de deux formules de la logique
des prédicats :
W = {∀x, Manchot(x) → Oiseau(x), Manchot(Titi)}
On sait aussi que Sauf exception, les oiseaux volent et que Sauf exception, les manchots ne
volent pas. On exprime ceci par un ensemble de deux défauts normaux D = {d1, d2} :
d1 = Oiseau(x):Vole(x)/Vole(x)
d2 = Manchot(x):¬Vole(x)/ ¬Vole(x)
Le défaut d1 peut aussi s’exprimer par : Si x est un oiseau et qu'il est consistant de
supposer que x peut voler, alors on conclue que x peut voler. On voit que si l’on utilisait les
deux défauts en même temps on obtiendrait que Vole(Titi) et ¬Vole(Titi) ce qui est
insatisfaisable. Pour cet exemple, on aura deux extensions. On a deux cas :
Cas 1: Dans ce cas on va commencer à construite l’extension en utilisant le défaut d1
- On part de E0
= W = Th({Manchot(Titi) → Oiseau(Titi), Manchot(Titi), Oiseau(Titi)})
- On utilise alors d1. Le prérequis de d1, Oiseau(Titi) est dans E0. La négation de la
justification de d1, ¬vole(Titi), n’est pas dans E0. Donc avec la définition d’une extension, on
peut ajouter Vole(Titi) à E0 pour obtenir E1.
E1
= Th({E0) ∪ Vole(Titi)})
- Ensuite on essaie d’utiliser d2 pour compléter E1. Le prérequis Manchot(Titi) est bien dans
E1. Mais Vole(Titi) qui est la négation de la justification de d2, est dans E1. Il est impossible
d’utiliser d2. Le calcul s’arrête et la première extension est E1. Dans cette extension, Titi vole.
Cas 2: On va maintenant commencer la construction de l’extension en utilisant d2
- On part de E0
= W = Th({Manchot(Titi) → Oiseau(Titi), Manchot(Titi), Oiseau(Titi)})
- On utilise alors d2. Le prérequis de d2, Manchot(Titi) est dans E0. La négation de la
justification de d2, Vole(Titi) n’est pas dans E0. Donc avec la définition d’une extension, on
peut ajouter ¬Vole(Titi) à E0 pour obtenir E1.
E1
= Th({E0) ∪ ¬Vole(Titi)})
- Ensuite on essaie d’utiliser d1 pour compléter E1. Le prérequis Manchot(Titi) est bien dans
E1. Mais Vole(Titi) qui est la négation de la justification de d2, est dans E1. Il est impossible 60 La logique des défauts
d’utiliser d2. Le calcul s’arrête et on a une deuxième extension dans laquelle Titi ne vole pas.
Figure 3.1. Arbre de recherche des solutions pour le calcul d'extensions
On obtient donc deux extensions qui sont contradictoires. Si nous cherchons à répondre à
la question : "Est-ce que Titi vole ?", il faut pouvoir choisir entre ces deux extensions. On
peut par exemple préférer les défauts les plus particuliers, ou encore établir des préférences
entre les défauts.
Comme nous venons de voir dans cet exemple, les théories des défauts peuvent avoir
plusieurs extensions. Il y a également des cas où elles n’ont pas d’extension. Dans certains
cas, ces défauts classiques peuvent donc poser des problèmes. Mais il est démontré qu’il
existe toujours une extension si W est satisfaisable et tous les défauts sont normaux [23].
3.6 Algorithme de calcul d’extensions.
Avant de décrire l’algorithme, on généralise la définition d’une extension en considérant
qu’un défaut peu avoir plusieurs prérequis. Pour que la logique des défauts travaille dans le
domaine de temps discret, il faut ajouter un argument temporal ti
. L’ensemble de faits W =
{w1, w2, …} est représenté avec l’argument comme W = {(w1,t0), (w2,t0), …}. Une extension de
la théorie des défauts ∆ = (D, W) est un ensemble E de formules, clos pour la déduction,
contenant W et vérifiant la propriété suivante : si d est un défaut de D dont les prérequis A(X)
(avec tk) sont dans E, sans que la négation des justifications Bi(X) ne soient dans E, alors le
conséquent C(X) (avec tk+1) de d est dans E. Formellement, les extensions sont définies de la
façon suivante :
E est une extension de ∆ si et seulement si � = ⋃�=0,∞ ��
, avec
E0 = W (avec t0) et pour i >0,
�� = �ℎ(��−1) ∪ {(�(�), t�+1)/(
�(�):��
(X)
�(�)
) ∈ �, (�(�), t�
), ∈ ��−1, ¬��(X)∉��−1}
où Th(Ei-1) désigne l'ensemble des théorèmes obtenus de façon monotone à partir de
��−1: �ℎ(��−1) = {�/��−1├�}. La logique des défauts 61
Pour une théorie des défauts ∆ = (D, W), avec D l'ensemble des défauts et W la base de
connaissance, le calcul d'extension se fait par l'algorithme :
Entrée :
D ; (ensemble des défauts).
� = ∅; (ensemble d'extension).
Sortie : � =∪�=0,� ��
.
calcul_extension(Ei) :{
Ei := W (en moment t0);
tantque il y a un défaut � =
�(�):��
(�)
�(�)
qui n'a pas encore été inspecté faire
- Sélectionner ce défaut d,
- Vérifier que les prérequis A(X) sont vrais avec Ei
(en moment tk),
- Vérifier que les justifications Bj(X) sont consistantes avec Ei (utiliser la négation
par échec en cas d'inconsistance),
- Ajouter (C(X), tk+1)) à Ei
fin tantque
Fin du calcul pour une extension.
Backtracking (Suppression des (C(X), tk+1) ajoutés à Ei).
calcul_extension(Ei).
} Approche proposée et résultats 63
Chapitre 4. Approche proposée et résultats
4.1. Utilisation de l’algorithme de production de clauses.
On revient à la carte d’interactions de Pommier. Pour passer du modèle biologique au
modèle logique, il faut considérer plusieurs contraintes : comment modéliser les interactions,
bien faire attention aux sens des implications logiques, respecter l'ordre chronologique
préalablement défini et vérifier la cohérence des informations [15]. L'étape initiale est de
définir correctement les prédicats. Ici les prédicats ont été calqués sur ceux de la carte de
Pommier, à savoir stimulation, phosphorylation, autophosphorylation, inhibition, nécessité,
liaison, activation de transcription, dégradation et déphosphorylation.
Au départ, les prédicats ont été conceptualisés, pour la majorité d'entre eux, de la façon
suivante : produit ⃪ réaction(enzyme, substrat). La réaction peut être stimulation,
phosphorylation, déphosphorylation, liaison, activation ou dégradation. Par exemple, p*-Y ⃪
phosphorylation(X, Y). Les autres prédicats qui ne sont pas de type produit ⃪
réaction(enzyme, substrat) sont modélisés séparément :
p*-Y ⃪ autophosphorylation(Y)
¬Y ⃪ inhibition(X, Y) : si X est vrai, alors Y ne peut pas l’être
Y ⃪ nécessité(X, Y) : pour que Y soit vrai, X doit être vrai
En effet, certains prédicats ont été modifiés, ou bien supprimés, au cours de
l’implémentation, tandis que d’autres ont été rajoutés grâce aux mises à jours effectuées dans
le modèle biologique et avec l’avancement de son implémentation dans Prolog. Par exemple,
les prédicats ajoutés sont ubiquitination, méthylation et dissociation.
Dans ce programme, cnf(nom_de_clause, type_de_clause, [littéraux]) indique une clause.
Pour la partie contenant des littéraux, chaque disjonction doit être indiquée par une virgule,
une négation par un signe moins, le signe plus peut être « oublié ». Voici un exemple qu’on
souhaite mettre au format de Prolog :
• D’abord, γH2AX se lie avec Mdc1.
• Ensuite, ATM peut phosphoryler Mdc1 liée à γH2AX.
• Mdc1, une fois phosphorylée, va se lier avec Rnf8.
• Enfin, Rnf8 va se lier avec Ubc13.
C’est modélisé par les équations logiques suivant les prédicats :
• Produit(γH2AX) → liaison(γH2AX, MDC1).
• Liaison(γH2AX, MDC1) → produit(γH2AX/MDC1).
• Produit(γH2AX/MDC1) → phosphorylation(ATM, γH2AX/MDC1).
• Phosphorylation(ATM, γH2AX/MDC1) → produit(p*-MDC1).
• Produit(p*-MDC1) → liaison(p*-MDC1, MRF8).64 Approche proposée et résultats
• Liaison(p*-MDC1, MRF8) → produit(MRF8_liée).
• Produit(MRF8_liée) → liaison(MRF8_liée, UBC13).
• Liaison(MRF8_liée, UBC13) → produit(MRF8/UBC13)
De façon plus intuitive, ceci peut être présenté par l’image ci – dessous :
Dans la Figure 4.1, une flèche à deux têtes présente une liaison, une flèche à une tête
présente une production, et une flèche brisée est une phosphorylation.
Suite, on replace les implications en utilisant les équivalences (A → B ≡ ¬A ⋁ B) :
• ¬Produit(γH2AX) ⋁ liaison(γH2AX, MDC1).
• ¬Liaison(γH2AX, MDC1) ⋁ produit(γH2AX/MDC1).
• ¬Produit(γH2AX/MDC1) ⋁ phosphorylation(ATM, γH2AX/MDC1).
• ¬Phosphorylation(ATM, γH2AX/MDC1) ⋁ produit(p*-MDC1).
• ¬Produit(p*-MDC1) ⋁ liaison(p*-MDC1, MRF8).
• ¬Liaison(p*-MDC1, MRF8) ⋁ produit(MRF8_liée).
• ¬Produit(MRF8_liée) ⋁ liaison(MRF8_liée, UBC13).
• ¬Liaison(MRF8_liée, UBC13) ⋁ produit(MRF8/UBC13)
Enfin, on adapte les équations au format de Prolog :
• cnf(mdc1_1, axiom, [-product(gamma_h2ax),binding(gamma_h2ax,mdc1)]).
• cnf(mdc1_2, axiom, [-binding(gamma_h2ax,mdc1),product(h2ax_mdc1)]).
• cnf(mdc1_3,axiom,[product(h2ax_mdc1),
phosphorylation(p_atm_bound,h2ax_mdc1)]).
• cnf(mdc1_4, axiom, [-phosphorylation(p_atm_bound,h2ax_mdc1),product(p_mdc1)]).
• cnf(rnf_01, axiom, [-product(p_mdc1),binding(p_mdc1,rnf8)]).
• cnf(rnf_02, axiom, [-binding(p_mdc1,rnf8),product(rnf8_bound)]).
• cnf(rnf_03, axiom, [-product(rnf8_bound),binding(rnf8_bound,ubc13)]).
• cnf(rnf_04, axiom, [-binding(rnf8_bound,ubc13),product(rnf8_ubc13)]).
ATM γH2AX/MDC1
γH2AX MDC1
P*-MDC1 MRF8
MRF8_liée UBC13
MRF8/UBC13
Figure 4.1. Interactions de la carte de PommierApproche proposée et résultats 65
À partir de la carte, avec la modélisation, on a adapté la base de données au format de
Prolog. Les lignes ci-dessous sont celles utilisées dans le modèle et qui relatent les
événements biologiques précédemment indiques :
/****************************************/
cnf(mrn_0, axiom, [-product(dsb),stimulation(dsb,dna)]).
cnf(mrn_1, axiom, [-stimulation(dsb,dna),product(altered_dna)]).
cnf(mrn_2, axiom, [-product(altered_dna),binding(mre11,rad50)]).
cnf(mrn_3, axiom, [-binding(mre11,rad50),product(mre11_rad50)]).
cnf(mrn_4, axiom, [-product(mre11_rad50),binding(mre11_rad50,nbs1)]).
cnf(mrn_5, axiom, [-binding(mre11_rad50,nbs1),product(mrn)]).
cnf(mrn_6, axiom, [-product(mrn),binding(mrn,altered_dna)]).
cnf(mrn_7, axiom, [-binding(mrn,altered_dna),product(mrn_bound_to_dna)]).
cnf(atm_1, axiom, [-product(mrn_bound_to_dna),binding(mrn_bound_to_dna,atm_atm)]).
cnf(atm_2, axiom, [-binding(mrn_bound_to_dna,atm_atm),product(atm_bound_to_mrn)]).
cnf(atm_3, axiom, [-product(atm_bound_to_mrn),-product(atm_atm)]).
cnf(atm_4, axiom, [-product(atm_bound_to_mrn),autophosphorylation(atm_bound_to_mrn)]).
cnf(atm_5, axiom, [-autophosphorylation(atm_bound_to_mrn),product(p_atm_atm_bound)]).
cnf(atm_6, axiom, [-product(p_atm_atm_bound),-product(atm_atm)]).
cnf(atm_7, axiom, [-product(p_atm_atm_bound),dissociation(p_atm_atm_bound)]).
cnf(atm_8, axiom, [-dissociation(p_atm_atm_bound),product(p_atm_bound)]).
cnf(atm_9, axiom, [-dissociation(p_atm_atm_bound),product(p_atm_free)]).
%Chk1 Phosphorylation
cnf(chk1_1, axiom, [-product(p_atm_free),phosphorylation(p_atm_free,chk1)]).
cnf(chk1_2, axiom, [-phosphorylation(p_atm_free,chk1),product(p_chk1)]).
cnf(chk1_3, axiom, [phosphorylation(atr,chk1)]).
cnf(chk1_4, axiom, [-phosphorylation(atr,chk1),product(p_chk1)]).
%Other MRN needs
cnf(mrn_add_1, axiom, [-product(mrn_bound_to_dna),product(p_smc1)]).
cnf(mrn_add_2, axiom, [-product(mrn_bound_to_dna),product(p_mre11)]).
%gamma-H2AX
cnf(h2ax_1, axiom, [-phosphorylation(atr,h2ax),product(gamma_h2ax)]).
cnf(h2ax_2, axiom, [-phosphorylation(p_atm_bound,h2ax),product(gamma_h2ax)]).
%MDC1, Ubiquitination and BRCA1
cnf(mdc1_1, axiom, [-product(gamma_h2ax),binding(gamma_h2ax,mdc1)]).
cnf(mdc1_2, axiom, [-binding(gamma_h2ax,mdc1),product(h2ax_mdc1)]).
cnf(mdc1_3, axiom, [-product(h2ax_mdc1),phosphorylation(p_atm_bound,h2ax_mdc1)]).
cnf(mdc1_4, axiom, [-phosphorylation(p_atm_bound,h2ax_mdc1),product(p_mdc1)]).
cnf(rnf_01, axiom, [-product(p_mdc1),binding(p_mdc1,rnf8)]).
cnf(rnf_02, axiom, [-binding(p_mdc1,rnf8),product(rnf8_bound)]).
cnf(rnf_03, axiom, [-product(rnf8_bound),binding(rnf8_bound,ubc13)]).
cnf(rnf_04, axiom, [-binding(rnf8_bound,ubc13),product(rnf8_ubc13)]).
cnf(rnf_05, axiom, [-product(rnf8_ubc13),ubiquitination(rnf8_ubc13,h2a)]).
cnf(rnf_06, axiom, [-ubiquitination(rnf8_ubc13,h2a),product(ub_h2a)]).
cnf(rnf_07, axiom, [-product(ub_h2a),binding(ub_h2a,rnf168)]).
cnf(rnf_08, axiom, [-binding(ub_h2a,rnf168),product(rnf168_bound)]).
cnf(rnf_09, axiom, [-product(rnf168_bound),binding(rnf168_bound,ubc13)]). 66 Approche proposée et résultats
cnf(rnf_10, axiom, [-binding(rnf168_bound,ubc13),product(rnf168_ubc13)]).
cnf(rnf_11, axiom, [-product(rnf168_ubc13),ubiquitination(rnf168_ubc13,h2a)]).
cnf(rnf_12, axiom, [-ubiquitination(rnf168_ubc13,h2a),product(poly_ub_h2a)]).
cnf(rnf_13, axiom, [-product(poly_ub_h2a),stimulation(poly_ub_h2a,dna)]).
cnf(rnf_14, axiom, [-stimulation(poly_ub_h2a,dna),product(changed_struct_dna)]).
cnf(rap_01, axiom, [-product(poly_ub_h2a),binding(poly_ub_h2a,rap80)]).
cnf(rap_02, axiom, [-binding(poly_ub_h2a,rap80),product(rap80_bound)]).
cnf(rap_03, axiom, [-product(rap80_bound),binding(rap80_bound,abraxas)]).
cnf(rap_04, axiom, [-binding(rap80_bound,abraxas),product(abraxas_bound)]).
cnf(rap_05, axiom, [-product(abraxas_bound),binding(abraxas_bound,bre)]).
cnf(rap_06, axiom, [-binding(abraxas_bound,bre),product(bre_bound)]).
cnf(rap_07, axiom, [-product(abraxas_bound),binding(abraxas_bound,brcc36)]).
cnf(rap_08, axiom, [-binding(abraxas_bound,brcc36),product(brcc36_bound)]).
cnf(rap_09, axiom, [-product(brcc36_bound),binding(brcc36_bound,merit40)]).
cnf(rap_10, axiom, [-binding(brcc36_bound,merit40),product(merit40_bound)]).
cnf(rap_10, axiom, [-product(merit40_bound),binding(merit40_bound,brcc36_bound)]).
cnf(rap_11, axiom, [-binding(merit40_bound,brcc36_bound),product(brcc36_merit40)]).
cnf(rap_12, axiom, [-product(brcc36_merit40),binding(brcc36_merit40,brca1)]).
cnf(rap_13, axiom, [-binding(brcc36_merit40,brca1),product(brca1_bound_to_rap80_complex)]).
%53BP1 binding
cnf(mmset_1, axiom, [-product(changed_struct_dna),phosphorylation(p_atm_bound,mmset)]).
cnf(mmset_2, axiom, [-phosphorylation(p_atm_bound,mmset),product(p_mmset)]).
cnf(mmset_3, axiom, [-product(h2ax_mdc1),binding(h2ax_mdc1,mdc1)]).
cnf(mmset_4, axiom, [-binding(h2ax_mdc1,mdc1),product(mdc1_multi)]).
cnf(mmset_5, axiom, [-product(mdc1_multi),-product(p_mmset),binding(mdc1_multi,p_mmset)]).
cnf(mmset_6, axiom, [-binding(mdc1_multi,p_mmset),product(mmset_mdc1)]).
cnf(mmset_7, axiom, [-product(mmset_mdc1),methylation(mmset_mdc1,h4)]).
cnf(mmset_8, axiom, [-methylation(mmset_mdc1,h4),product(h4k20me2)]).
cnf(p53bp1_1,axiom,[-product(h4k20me2),-product(brca1_bound_to_rap80_complex),
binding(h4k20me2,p53bp1)]).
cnf(p53bp1_2, axiom, [-binding(h4k20me2,p53bp1),product(p53bp1_bound)]).
cnf(p53bp1_3, axiom, [-product(p53bp1_bound),phosphorylation(p_atm_bound,p53bp1_bound)]).
cnf(p53bp1_4, axiom, [-phosphorylation(p_atm_bound,p53bp1_bound),product(p_53bp1)]).
%Chk2 formation with Plk3 action (and binding with 53bp1)
cnf(plk3_1, axiom, [-product(p_atm_free),phosphorylation(p_atm_free,plk3)]).
cnf(plk3_2, axiom, [-phosphorylation(p_atm_free,plk3),product(p_plk3)]).
cnf(chk2_01, axiom, [-product(p_atm_free),phosphorylation(p_atm_free,chk2)]).
cnf(chk2_02, axiom, [-phosphorylation(p_atm_free,chk2),product(p_s33_35_chk2)]).
cnf(chk2_03, axiom, [-product(p_s33_35_chk2),phosphorylation(p_plk3,p_s33_35_chk2)]).
cnf(chk2_04, axiom, [-phosphorylation(p_plk3,p_s33_35_chk2),product(p_s33_35_s62_73_chk2)]).
cnf(chk2_05,axiom,[-product(p_s33_35_s62_73_chk2),
phosphorylation(p_atm_free,p_s33_35_s62_73_chk2)]).
cnf(chk2_06, axiom, [-phosphorylation(p_atm_free,p_s33_35_s62_73_chk2),product(p_t68_chk2)]).
cnf(chk2_07,axiom,[-product(p_s33_35_s62_73_chk2),
phosphorylation(atr,p_s33_35_s62_73_chk2)]).
cnf(chk2_08, axiom, [-phosphorylation(atr,p_s33_35_s62_73_chk2),product(p_t68_chk2)]).
cnf(chk2_09, axiom, [-product(p_t68_chk2),binding(p_t68_chk2,p_t68_chk2)]).
cnf(chk2_10, axiom, [-binding(p_t68_chk2,p_t68_chk2),product(chk2_chk2)]).
cnf(chk2_11, axiom, [-product(chk2_chk2),autophosphorylation(chk2_chk2)]).
cnf(chk2_12, axiom, [-autophosphorylation(chk2_chk2),product(p_active_chk2_chk2)]).
cnf(chk2_13,axiom,[-product(p_active_chk2_chk2),-product(p_53bp1),
binding(p_active_chk2_chk2,p_53bp1)]). Approche proposée et résultats 67
cnf(chk2_13, axiom, [-binding(p_active_chk2_chk2,p_53bp1),product(chk2_53bp1)]).
%BRCA1 regulation by CtIP and Chk2
cnf(ctip_1, axiom, [binding(brca1,ctip)]).
cnf(ctip_2, axiom, [-binding(brca1,ctip),product(brca1_ctip)]).
cnf(ctip_3, axiom, [-product(brca1_ctip),-product(chk2_53bp1),binding(brca1_ctip,chk2_53bp1)]).
cnf(ctip_4, axiom, [-binding(brca1_ctip,chk2_53bp1),product(chk2_53bp1_bound_to_brca1)]).
cnf(ctip_5, axiom, [-binding(brca1_ctip,chk2_53bp1),product(brca1_ctip_bound_to_chk2)]).
cnf(ctip_6,axiom,[-product(chk2_53bp1_bound_to_brca1),-product(brca1_ctip_bound_to_chk2),
phosphorylation(chk2_53bp1_bound_to_brca1,brca1_ctip_bound_to_chk2)]).
cnf(ctip_7,axiom,[-phosphorylation(chk2_53bp1_bound_to_brca1,brca1_ctip_bound_to_chk2),
product(p_brca1_ctip_bound_to_chk2)]).
cnf(ctip_8, axiom, [-product(p_brca1_ctip_bound_to_chk2),product(p_s988_brca_ctip)]).
cnf(ctip_9, axiom, [-product(chk2_53bp1_bound_to_brca1),product(chk2_53bp1)]).
cnf(brca1_0,axiom,[-product(p_s988_brca_ctip), phosphorylation(p_atm_bound,p_s988_brca_ctip)]).
cnf(brca1_1, axiom, [-phosphorylation(p_atm_bound,p_s988_brca_ctip),product(brca_p_ctip)]).
cnf(brca1_2, axiom, [-product(brca_p_ctip),-product(brca1_ctip)]).
cnf(brca1_3, axiom, [-product(brca_p_ctip),dissociation(brca_p_ctip)]).
cnf(brca1_4, axiom, [-dissociation(brca_p_ctip),product(brca1)]).
cnf(brca1_5, axiom, [-dissociation(brca_p_ctip),product(p_ctip)]).
cnf(brca1_6, axiom, [-product(brca1),phosphorylation(p_atm_bound,brca1)]).
cnf(brca1_7, axiom, [-phosphorylation(p_atm_bound,brca1),product(p_brca1)]).
cnf(brca1_8, axiom, [-product(brca1),phosphorylation(atr,brca1)]).
cnf(brca1_9, axiom, [-phosphorylation(atr,brca1),product(p_brca1)]).
%DNA repair proposed mecasism
cnf(repa_1, axiom, [-product(p_brca1),-product(p_53bp1),binding(mrn_bound_to_dna,p_brca1)]).
cnf(repa_2, axiom, [-binding(mrn_bound_to_dna,p_brca1),product(brca1_bound_to_mrn)]).
%p53 pathway and regulation including PML
cnf(pml_1, axiom, [-product(chk2_53bp1),phosphorylation(chk2_53bp1,pml)]).
cnf(pml_2, axiom, [-phosphorylation(chk2_53bp1,pml),product(p_pml)]).
cnf(pml_3, axiom, [-product(p_pml),stimulation(p_pml,cell)]).
cnf(pml_4, axiom, [-stimulation(p_pml,cell),product(apoptosis)]).
cnf(pml_5, axiom, [-product(p_pml),binding(p_pml,mdm2)]).
cnf(pml_6, axiom, [-binding(p_pml,mdm2),product(pml_mdm2)]).
cnf(pml_7, axiom, [-product(pml_mdm2),-binding(mdm2,p53)]).
cnf(mdm2_1, axiom, [product(p53)]).
cnf(mdm2_2, axiom, [-product(mdm2),-product(p53),binding(mdm2,p53)]).
cnf(mdm2_3, axiom, [-binding(mdm2,p53),product(mdm2_p53)]).
cnf(mdm2_4, axiom, [-product(mdm2_p53),stimulation(p53_degradation_effectors,mdm2_p53)]).
cnf(mdm2_5,axiom,[-stimulation(p53_degradation_effectors,mdm2_p53),
product(p53_degradation)]).
cnf(p53_01,axiom,[-product(p_atm_free),-product(mdm2_p53),
phosphorylation(p_atm_free,mdm2_p53)]).
cnf(p53_02, axiom, [-phosphorylation(p_atm_free,mdm2_p53),product(p_s15_p53_mdm2)]).
cnf(p53_03, axiom, [-product(mdm2_p53),phosphorylation(atr,mdm2_p53)]).
cnf(p53_04, axiom, [-phosphorylation(atr,mdm2_p53),product(p_s15_p53_mdm2)]).
cnf(p53_05,axiom,[-product(p_s15_p53_mdm2),-product(chk2_53bp1),
phosphorylation(chk2_53bp1,p_s15_p53_mdm2)]).
cnf(p53_06, axiom, [-phosphorylation(chk2_53bp1,p_s15_p53_mdm2),product(p_p_p53_mdm2)]).
cnf(p53_07,axiom,[-product(p_s15_p53_mdm2),-product(p_chk1),
phosphorylation(p_chk1,p_s15_p53_mdm2)]). 68 Approche proposée et résultats
cnf(p53_08, axiom, [-phosphorylation(p_chk1,p_s15_p53_mdm2),product(p_p_p53_mdm2)]).
cnf(p53_09, axiom, [-product(p_s15_p53_mdm2),-product(p53_degradation)]).
cnf(p53_10, axiom, [-product(p_p_p53_mdm2),-product(p53_degradation)]).
cnf(p53_11, axiom, [-product(p_p_p53_mdm2),dissociation(p_p_p53_mdm2)]).
cnf(p53_12, axiom, [-dissociation(p_p_p53_mdm2),product(p_p_p53)]).
cnf(p53_13, axiom, [-dissociation(p_p_p53_mdm2),product(mdm2)]).
cnf(p53_14, axiom, [-product(p_atm_free),-product(mdm2),phosphorylation(p_atm_free,mdm2)]).
cnf(p53_15, axiom, [-phosphorylation(p_atm_free,mdm2),product(p_mdm2)]).
cnf(p53_16, axiom, [-product(p_p_p53),binding(p300,p_p_p53)]).
cnf(p53_17, axiom, [-product(p_pml),-binding(p300,p_p_p53),product(active_p53)]).
cnf(p53_18,axiom,[-product(active_p53), transcription_activation(active_p53,prom_p21_gadd45)]).
cnf(p53_19,axiom,[-transcription_activation(active_p53,prom_p21_gadd45),
product(p21_and_gadd45)]).
cnf(p53_19a, axiom, [-product(p21_and_gadd45),stimulation(p21_and_gadd45,cell_cycle)]).
cnf(p53_20, axiom, [-stimulation(p21_and_gadd45,cell_cycle),product(cell_cycle_arrest)]).
cnf(p53_21, axiom, [-product(active_p53),transcription_activation(active_p53,prom_bnpf)]).
cnf(p53_22,axiom,[-transcription_activation(active_p53,prom_bnpf), product(box_nas_puma_fas)]).
cnf(p53_23, axiom, [-product(box_nas_puma_fas),stimulation(box_nas_puma_fas,cell)]).
cnf(p53_24, axiom, [-stimulation(box_nas_puma_fas,cell),product(apoptosis)]).
cnf(p53_21, axiom, [-product(active_p53),transcription_activation(active_p53,prom_mdm2)]).
cnf(p53_22, axiom, [-transcription_activation(active_p53,prom_mdm2),product(mdm2)]).
%E2F1 action
cnf(e2f1_00, axiom, [product(e2f1)]).
cnf(e2f1_01, axiom, [-product(e2f1),-product(chk2_53bp1),phosphorylation(chk2_53bp1,e2f1)]).
cnf(e2f1_02, axiom, [-phosphorylation(chk2_53bp1,e2f1),product(p_e2f1)]).
cnf(e2f1_03, axiom, [-product(e2f1),stimulation(e2f1_degradation_effectors,e2f1)]).
cnf(e2f1_04, axiom, [-stimulation(e2f1_degradation_effectors,e2f1),product(e2f1_degradation)]).
cnf(e2f1_05, axiom, [-product(p_e2f1),-product(e2f1_degradation)]).
cnf(e2f1_06, axiom, [-product(p_e2f1),phosphorylation(p_atm_free,p_e2f1)]).
cnf(e2f1_07, axiom, [-phosphorylation(p_atm_free,p_e2f1),product(p_p_e2f1)]).
cnf(e2f1_08, axiom, [-product(p_e2f1),phosphorylation(atr,p_e2f1)]).
cnf(e2f1_09, axiom, [-phosphorylation(atr,p_e2f1),product(p_p_e2f1)]).
cnf(e2f1_10, axiom, [-product(p_p_e2f1),transcription_activation(p_p_e2f1,prom_chk2)]).
cnf(e2f1_11, axiom, [-transcription_activation(p_p_e2f1,prom_chk2),product(chk2)]).
cnf(e2f1_12, axiom, [-product(p_p_e2f1),transcription_activation(p_p_e2f1,prom_arf)]).
cnf(e2f1_13, axiom, [-transcription_activation(p_p_e2f1,prom_arf),product(arf)]).
cnf(e2f1_14, axiom, [-product(p_p_e2f1),transcription_activation(p_p_e2f1,prom_p73_apaf1)]).
cnf(e2f1_15, axiom, [-transcription_activation(p_p_e2f1,prom_p73_apaf1),product(p73_apaf1)]).
cnf(e2f1_16, axiom, [-product(p73_apaf1),stimulation(p73_apaf1,cell)]).
cnf(e2f1_17, axiom, [-stimulation(p73_apaf1,cell),product(apoptosis)]).
cnf(e2f1_18, axiom, [-product(arf),binding(arf,mdm2)]).
cnf(e2f1_19, axiom, [-binding(arf,mdm2),product(arf_mdm2)]).
cnf(e2f1_20, axiom, [-product(arf_mdm2),-product(mdm2_p53)]).
cnf(e2f1_21, axiom, [-product(p_p_e2f1),stimulation(p_p_e2f1,unknown_atm_way)]).
cnf(e2f1_22, axiom, [-stimulation(p_p_e2f1,unknown_atm_way),product(p_atm_free)]).
%p38 phosphorylation (usefull for cdc25c and cdc25b)
cnf(p38_1, axiom, [-product(p_atm_free),phosphorylation(p_atm_free,p38)]).
cnf(p38_2, axiom, [-phosphorylation(p_atm_free,p38),product(p_p38)]).
%Cdc25 regulation
cnf(cdc25a_0, axiom, [-stimulation(cdc25a,cell),-product(cell_cycle_arrest)]).Approche proposée et résultats 69
cnf(cdc25a_1, axiom, [-product(chk2_53bp1),phosphorylation(chk2_53bp1,cdc25a)]).
cnf(cdc25a_2, axiom, [-phosphorylation(chk2_53bp1,cdc25a),product(p_cdc25a)]).
cnf(cdc25a_3, axiom, [-product(p_chk1),phosphorylation(p_chk1,cdc25a)]).
cnf(cdc25a_4, axiom, [-phosphorylation(p_chk1,cdc25a),product(p_cdc25a)]).
cnf(cdc25a_5, axiom, [-product(p_cdc25a),stimulation(p_cdc25a,cdc25a_degradation_effectors)]).
cnf(cdc25a_6,axiom,[-stimulation(p_cdc25a,cdc25a_degradation_effectors),
product(cdc25a_degradation)]).
cnf(cdc25a_7, axiom, [-product(cdc25a_degradation),-stimulation(cdc25a,cell)]).
cnf(cdc25c_00, axiom, [-stimulation(cdc25c,cell),-product(cell_cycle_arrest)]).
cnf(cdc25c_01, axiom, [-product(chk2_53bp1),phosphorylation(chk2_53bp1,cdc25c)]).
cnf(cdc25c_02, axiom, [-phosphorylation(chk2_53bp1,cdc25c),product(p_cdc25c)]).
cnf(cdc25c_03, axiom, [-product(p_plk3),phosphorylation(p_plk3,cdc25c)]).
cnf(cdc25c_04, axiom, [-phosphorylation(p_plk3,cdc25c),product(p_cdc25c)]).
cnf(cdc25c_05, axiom, [-product(p_chk1),phosphorylation(p_chk1,cdc25c)]).
cnf(cdc25c_06, axiom, [-phosphorylation(p_chk1,cdc25c),product(p_cdc25c)]).
cnf(cdc25c_07, axiom, [-product(p_p38),phosphorylation(p_p38,cdc25c)]).
cnf(cdc25c_08, axiom, [-phosphorylation(p_p38,cdc25c),product(p_cdc25c)]).
cnf(cdc25c_09, axiom, [-product(p_cdc25c),stimulation(p_cdc25c,cdc25c_degradation_effectors)]).
cnf(cdc25c_10,axiom,[-stimulation(p_cdc25c,cdc25c_degradation_effectors),
product(cdc25c_degradation)]).
cnf(cdc25c_11, axiom, [-product(cdc25c_degradation),-stimulation(cdc25c,cell)]).
cnf(cdc25b_1, axiom, [-stimulation(cdc25b,cell),-product(cell_cycle_arrest)]).
cnf(cdc25b_2, axiom, [-product(p_p38),phosphorylation(p_p38,cdc25b)]).
cnf(cdc25b_3, axiom, [-phosphorylation(p_p38,cdc25b),product(p_cdc25b)]).
cnf(cdc25b_4, axiom, [-product(p_cdc25b),-stimulation(cdc25b,cell)]).
%JNK actions (mechanisms quite unclear)
cnf(jnk_1, axiom, [-stimulation(jnk,cdc25c),product(p_cdc25c)]).
cnf(jnk_2, axiom, [-phosphorylation(jnk,p_s15_p53_mdm2),product(p_p_p53_mdm2)]).
%FANCD2 first steps
cnf(fancd2_1, axiom, [-product(p_atm_bound),phosphorylation(p_atm_bound,nbs1)]).
cnf(fancd2_2, axiom, [-phosphorylation(p_atm_bound,nbs1),product(p_nbs1)]).
cnf(fancd2_3, axiom, [-product(p_nbs1),phosphorylation(p_atm_bound,fancd2)]).
cnf(fancd2_4, axiom, [-phosphorylation(p_atm_bound,fancd2),product(p_fancd2)]).
cnf(fancd2_5, axiom, [-product(p_fancd2),stimulation(p_fancd2,cell)]).
cnf(fancd2_6, axiom, [-stimulation(p_fancd2,cell),-product(cell_cycle_arrest)]).
%Mus81 actions on DNA Repair
cnf(mus81_1, axiom, [-product(chk2_53bp1),binding(chk2_53bp1,mus81)]).
cnf(mus81_2, axiom, [-binding(chk2_53bp1,mus81),product(mus81_chk2)]).
cnf(mus81_3, axiom, [-product(mus81_chk2),binding(mus81_chk2,altered_dna)]).
cnf(mus81_4, axiom, [-binding(mus81_chk2,altered_dna),product(mus81_bound_to_dna)]).
%cnf(mus81_5, axiom, [-binding(mus81_chk2,altered_dna),product(mus81_bound_to_dna)]).
/****************************************/
Le résultat : Avec le champ de production champ([_,1,[stimulation(_,_)],_]), après l’exécution de
programme, le résultat est donné
Pour activer product(cell_cycle_arrest):
-stimulation(p21_and_gadd45,cell_cycle) 70 Approche proposée et résultats
% 261,290 inferences, 0.156 CPU in 20.794 seconds (1% CPU, 1674925 Lips)
Pour bloquer product(cell_cycle_arrest) :
-stimulation(cdc25a,cell)
-stimulation(cdc25c,cell)
-stimulation(cdc25b,cell)
-stimulation(dsb,dna)
-stimulation(p_fancd2,cell)
% 18,008 inferences, 0.047 CPU in 7.993 seconds (1% CPU, 384784 Lips)
Pour activer product(apoptosis) :
-stimulation(p_pml,cell)
-stimulation(box_nas_puma_fas,cell)
-stimulation(p73_apaf1,cell)
% 154,139 inferences, 0.094 CPU in 20.310 seconds (0% CPU, 1646774 Lips)
Pour bloquer product(apoptosis), le résultat est un ensemble vide de clauses.
4.2. Utilisation de la logique des défauts
4.2.1. Dans le cas général
La Figure 4.2 représente un exemple très simplifié d'interactions dans une cellule.
Figure 4.2. Un exemple d’interactions dans une celluleApproche proposée et résultats 71
Par des mécanismes divers non indiqués ici, les ultraviolets (UV) mettent la cellule en
apostase (elle devient de fait immortelle) d'où le cancer. Ceci est représenté par une flèche.
D'un autre coté les UV activent la production de la protéine p53. Cette protéine va activer une
protéine A qui va bloquer le cancer. Mais p53 liée à la protéine Mdm2 va produire B, qui va
bloquer A. Pour un biologiste, la question est donc de bloquer le cancer en bloquant B. Les
expériences biologiques ont montré que le X pourrait être un candidat pour ce blocage. Les
figures (b) et (c) donnent deux types d'interactions possibles avec X pour expliquer ce blocage
de B. Le problème est d'utiliser l'informatique pour compléter le graphe [3].
Pour décrire les interactions entre les gênes dans la figure, on part d’un langage L de
logique classique (propositionnel ou du premier ordre). Dans L, la proposition A (resp ¬A)
signifie que A est vrai (faux). Les interactions entres les gênes sont une forme très simple de
causalité. Pour exprimer ces interactions il est courant d'aller à l'essentiel en donnant deux
relations binaires cause(A, B) et bloque(A, B). La première relation veut dire, par exemple,
qu'une protéine A déclenche la production d'une protéine B, la deuxième est l’inhibition. De
manière classique, ces relations sont représentées dans le réseau de gênes, par A → B et A ⊣
B. Bien entendu, ces causalités sont élémentaires et de nombreux travaux très savants ont été
écrits pour les représenter.
Pour représenter les liens entre les relations, dans le langage L, il faut faire deux choses :
décrire les propriétés internes aux relations cause et bloque ; décrire les liens entre ces
relations.
Les premières propriétés que l’on a envie de donner peuvent s’exprimer naturellement,
par des règles du type :
(1) Si A cause B et si A est vrai, alors B est vrai.
(2) Si A bloque B et si A est vrai, alors B est faux.
La solution élémentaire est alors de donner explicitement les deux schémas d'axiomes :
(C1) cause(A,B) ∧ cause(B, C) → cause(A, C)
(C2) cause(A, B) ∧ bloque (B, C) → bloque(A, C)
La première idée est d'exprimer ces lois en logique classique par les axiomes :
cause(A, B) ∧ A → B
bloque(A, B) ∧ A → ¬B
On peut aussi les exprimer plus faiblement par des règles d'inférences proches du modus
ponens :
cause(A, B) ∧ A / B
bloque(A, B) ∧ A / ¬B72 Approche proposée et résultats
Mais ces deux formulations posent problème dès qu'il y a conflit. Si par exemple on a un
ensemble F de quatre formules F = {A, B, cause(A, C), bloque(B, C)}, alors on va dans les
deux approches données ci-dessus inférer de F, C et ¬C ce qui est inconsistant. Pour résoudre
ce conflit, on peut utiliser la logique des défauts.
Pour résoudre les conflits vus ci-dessus, l'idée intuitive est d'affaiblir la formulation des règles
de causalité en :
(1') Si A cause B, et si A est vrai, et s'il est possible que B est vrai, alors B est vrai.
(2') Si A bloque B, et si A est vrai, et s'il est possible que B est faux, alors B est faux.
Dans la logique des défauts, les règles (1') et (2') vont s'exprimer intuitivement.
(1") Si A cause B, et si A est vrai, et si B n'est pas contradictoire, alors B est vrai.
(2") Si A bloque B, et si A est vrai, et si ¬B n'est pas contradictoire, alors ¬B est vrai.
Ces règles vont se représenter par des défauts normaux et s'écrire :
d1 : cause(A, B) ∧ A : B / B
d2 : bloque(A, B) ∧ A : ¬B / ¬B
Pour le cas élémentaire qui précède, si A et B sont vrais, on a :
W = {A, B, cause(A,C), bloque(B,C)}
D = {d1, d2}
et on obtient deux extensions :
E1 contient C (en appliquant d1)
E2 contient ¬C (en appliquant d2)
Le conflit est donc résolu, mais se pose le problème des extensions à préférer ; est-ce que
C est induit ou bloqué? En fait ceci va vraiment dépendre du contexte. On peut par exemple
préférer les interactions positives par rapport aux négatives ; ou bien utiliser des méthodes
statistiques ou probabilistes.
Plus en détail, pour l’application, on a [28]:
W = {UV, Mdm2}
D = { d1 = UV : cancer / cancer
d2 = UV : p53 / p53
d3 = p53 : A / A
d4 = p53 ∧ Mdm2: B / BApproche proposée et résultats 73
d5 = B : ¬A / ¬A
d6 = A : ¬cancer / ¬cancer
d7 = C : ¬B / ¬B
}
On a encore deux défauts généraux :
d8 = Y : x /x ; où Y ∈ {UV, Mdm2}
et d9 = Z ∧ x: C / C; où Z ∈ {UV, Mdm2, p53, A, B}
Comme on a dit précédemment, pour que l’algorithme travaille avec des variables, il faut
l’améliorer. Dans ce cas, les défauts d8 et d9 peuvent être écrits :
source(uv). % UV est une source
source(mdm2).
substance(uv). % UV est une substance
substance(mdm2).
substance(p53).
substance(a).
substance(b).
ecrit:
source(Y), % « ordre 1 »
assert(cl(def(Y,x))), % « ordre 2 »
substance(Z), % « ordre 3 »
assert(cl(def(joint(Z,x),c))). % « ordre 4 »
où « ordre 1 » et « ordre 2 » peuvent dire : pour toutes les sources Y, ajouter les défauts
Y:x/x à la base de données ; « ordre 3 » et « ordre 4 » peuvent dire : pour toutes les substances
Z, ajouter les défauts Z∧ x:C/C à la base de données.
En utilisant l’algorithme de calculer des extensions, on a 18 extensions cidessous
(l’extension 12 correspond à la Figure 4.2-b, et l’extension 13 correspond à la Figure
4.2-c) :
EXTENSION 1:
uv -> p53
p53 -> a74 Approche proposée et résultats
joint(p53,mdm2) -> b
uv -> x
joint(uv,x) -> c
a -> -cancer
EXTENSION 2:
uv -> p53
p53 -> a
joint(p53,mdm2) -> b
uv -> x
joint(mdm2,x) -> c
a -> -cancer
EXTENSION 3:
uv -> p53
p53 -> a
joint(p53,mdm2) -> b
uv -> x
joint(p53,x) -> c
a -> -cancer
EXTENSION 4:
uv -> p53
p53 -> a
joint(p53,mdm2) -> b
uv -> x
joint(a,x) -> c
a -> -cancer
EXTENSION 5:
uv -> p53
p53 -> a
joint(p53,mdm2) -> b
uv -> x
joint(b,x) -> c
a -> -cancer
EXTENSION 6:
uv -> p53
p53 -> a
joint(p53,mdm2) -> b
mdm2 -> x
joint(uv,x) -> c
a -> -cancerApproche proposée et résultats 75
EXTENSION 7:
uv -> p53
p53 -> a
joint(p53,mdm2) -> b
mdm2
-> x
joint(mdm2,x) -> c
a ->
-cancer
EXTENSION 8:
uv -> p53
p53 -> a
joint(p53,mdm2) -> b
mdm2
-> x
joint(p53,x) -> c
a ->
-cancer
EXTENSION 9:
uv -> p53
p53 -> a
joint(p53,mdm2) -> b
mdm2
-> x
joint(a,x) -> c
a ->
-cancer
EXTENSION 10:
uv -> p53
p53 -> a
joint(p53,mdm2) -> b
mdm2
-> x
joint(b,x) -> c
a ->
-cancer
EXTENSION 11:
uv -> p53
p53 -> a
uv
-> x
joint(uv,x) -> c
c
-> -b
a ->
-cancer
EXTENSION 12:
uv -> p53
p53 -> a
uv
-> x
joint(mdm2,x) -> c76 Approche proposée et résultats
c -> -b
a -> -cancer
EXTENSION 13:
uv -> p53
p53 -> a
uv -> x
joint(p53,x) -> c
c -> -b
a -> -cancer
EXTENSION 14:
uv -> p53
p53 -> a
uv -> x
joint(a,x) -> c
c -> -b
a -> -cancer
EXTENSION 15:
uv -> p53
p53 -> a
mdm2 -> x
joint(uv,x) -> c
c -> -b
a -> -cancer
EXTENSION 16:
uv -> p53
p53 -> a
mdm2 -> x
joint(mdm2,x) -> c
c -> -b
a -> -cancer
EXTENSION 17:
uv -> p53
p53 -> a
mdm2 -> x
joint(p53,x) -> c
c -> -b
a -> -cancer
EXTENSION 18:
uv -> p53 Approche proposée et résultats 77
p53 -> a
mdm2 -> x
joint(a,x) -> c
c -> -b
a -> -cancer
% 599,907 inferences, 1.700 CPU in 2.402 seconds (71% CPU, 352801 Lips)
4.2.2. Utilisation dans le domaine temporel discret
Bien que les cellules aient des morphologies et des structures différentes et que leurs
rôles dans les organismes différents soient variés, leurs fonctionnalités de base sont les mêmes
[1,4]. Une de ces fonctionnalités est d'assurer la survie de la cellule. Cette activité dans son
ensemble peut être résumée en deux points [21]. Premièrement, une cellule a besoin de
trouver l'énergie nécessaire pour son activité. Cette énergie est principalement obtenue par la
dégradation des ressources minérales ou organiques, c’est le catabolisme. Deuxièmement, les
cellules doivent fabriquer les molécules simples nécessaires à leur survie, c’est l’anabolisme.
Ces deux grandes activités sont regroupées sous le nom de métabolisme, et résultent d'un
grand nombre de mécanismes et de réactions biochimiques. La plupart des réactions, qui se
déroulent dans une cellule, sont catalysées par des molécules spéciales appelées enzymes.
Tout ceci est représenté comme un réseau, appelé voie métabolique [20].
Figure 4.3. Système équilibré de masse
La Figure 4.3 représente la topologie simple d'une voie métabolique dans une cellule, qui
se compose de cinq métabolites A, B, C, D et E et six réactions, dont chacune relie deux
métabolites. Chaque flux est placé sur la réaction correspondante. Bien que les concentrations
de A, C, D et E soient expérimentalement mesurables, la concentration de B ne peut pas être
mesurée. Par conséquent, B est le métabolite intracellulaire. Sur la base de la cinétique
enzymatique, le comportement dynamique du flux d'une réaction enzymatique peut être
représenté comme l'équation différentielle suivante:
���
��
= ��� − ���� − ��� (4.2)
où Cx est la concentration d'un métabolite X, vin (resp. vout) est la somme des flux de réactions
pour la production (resp. consommation) de X, et μCX représente le taux de croissance de la
biomasse dans une cellule. Si tous les métabolites sont à l'état stationnaire, le terme de gauche
de l'équation (4.2) doit être nul car il n'y a pas de changements de séries chronologiques des
concentrations, et aussi, on peut supposer que la dilution des éléments à cause de la croissance 78 Approche proposée et résultats
de la biomasse (correspondant à la durée de la dernière équation (4.2)) est négligée. Ce fait
signifie que pour chaque métabolite X, les flux de consommation de X sont équilibrés avec les
flux de production de X à l'état stationnaire. L’équilibrage de flux métabolique est basé sur
cette notion simple. Par exemple, son équilibrage dans la Figure 4.3 peut être représenté
comme les équations linéaires suivantes:
�1 = ��, �2 + �3
+ = �3
− + �1, �5 = �2 + ��, �4 + �� = �5, �3
− + �� = �3
+ + �4 (4.3)
Ensuite, nous pouvons analyser la distribution du flux sur la base des équations (4.3) avec
les flux mesurables rA, rC, rD et rE. En général, ces équations ne peuvent pas être résolues de
façon déterministe parce que le nombre de valeurs inconnues comme v1,. . . , v5 correspondant
aux flux de réactions enzymatiques intracellulaires devient plus grand que le nombre de
valeurs connues correspondant aux flux mesurables. Des méthodes ont été proposées
précédemment telles que l'analyse en mode primaire et extrêmes de la voie, des fonctions
d'analyse d'utilisation d'optimisation afin de résoudre les équations. Ces fonctions introduites
sont généralement construites en supposant que la maximisation de la croissance cellulaire ou
la minimisation de la consommation d'énergie. Toutefois, dans le cas d'une grande échelle de
la voie métabolique, nous ne pouvons pas résoudre la distribution de flux avec ces méthodes
d'approximation en raison du coût de calcul énorme.
Le système métabolique cellulaire dispose d'un mécanisme sophistiqué pour contrôler
dynamiquement les activités des enzymes pour répondre aux besoins d'une cellule. Ce
mécanisme de régulation peut être représenté comme des relations causales entre les activités
enzymatiques et la concentration de métabolites changeants. Ici, nous considérons trois voies
métaboliques simples: la première se compose de deux réactions avec trois métabolites, la
seconde se compose de deux réactions avec trois métabolites aussi, et la troisième se compose
d'une réaction avec deux métabolites. Noter que dans les figures suivantes, nous décrivons
activé et non-activé par des réactions comme les cercles et barres obliques plus flèches
correspondant aux réactions, respectivement. Et aussi, une hausse (resp. baisse) flèche
représente l'augmentation (resp. la diminution) à une concentration de métabolites.
La figure 4.4 correspond à la voie métabolique composée de trois métabolites X, Y et Z, et
deux réactions. La figure dit que si la concentration de Y tend à augmenter à un certain
moment, et si la réaction enzymatique Y→X (resp. X→Z) est activée (resp. non-activée) dans
un état, alors la concentration de X va aussi augmenter. Cette relation causale est prise en
compte par l'équation (4.2). Supposons que l'augmentation de la concentration de X est
observée, ce qui est représentée par une flèche en pointillés dans les figures. Un cas possible
est que la concentration de Y augmente, la réaction de Y→X est activée et la réaction X→Z
n'est pas activée. Ceci parce que la production de X à partir de Y ne peut pas être consommée
pour générer le Z. Approche proposée et résultats 79
Figure 4.4. La première relation entre les états de réaction et les changements de concentration de
métabolites
La Figure 4.5 correspond à la voie métabolique composée de trois métabolites X, Y et Z,
et deux réactions. La figure montre que si la concentration de Y tend à augmenter à un certain
moment, et si la réaction enzymatique Y→X (resp. X→Z) est non-activée (resp. activée) dans
un l'état, alors la concentration de X va diminuer. Cette relation causale est prise en compte
par l'équation (4.2). Supposons que la diminution de la concentration de X est observée, ce qui
est désignée par une flèche en pointillés dans les figures. Un cas possible est que la
concentration de Y augmente, la réaction de Y→X n’est pas activée et la réaction X→Z est
activée. C'est parce que la production de Z à partir de X peut être consommée.
Figure 4.5. La deuxième relation entre les états de réaction et les changements de concentration de
métabolites
Ensuite, nous considérons la Figure 4.6 qui représente une voie métabolique composée de
deux métabolites X et Y, et une réaction. La figure montre que, même si la réaction Y→X est
activée, la concentration de X doit diminuer en ce que la concentration de Y diminue. Par
conséquent, si nous observons que la concentration de X diminue, on peut supposer une
diminution de la concentration de Y et la réaction Y→X est activée comme un cas possible.
Figure 4.6. La troisième relation entre les états de réaction et les changements de concentration de
métabolites
Les métabolites et les protéines sont considérés comme un même objet. On va souvent se
restreindre ici à une représentation propositionnelle. Dans la pratique l'étude fine des
interactions va demander de représenter des augmentations ou des diminutions de
concentration de protéines. On sort donc du cadre propositionnel mais les problèmes de base
sont les mêmes. Pour représenter une variation de concentration il est par exemple possible
d'utiliser des prédicats de type "augmente" ou "diminue" et de limiter l'utilisation de ces
prédicats.
Pour décrire les interactions entre les métabolites dans la cellule, on part d’un langage L
de logique classique (propositionnel ou du premier ordre). Dans L, la proposition A (resp ¬A)
signifie que A est vrai (faux). On pourra utiliser par exemple con(A, up, ti) pour dire que la
Y X Z
Y X Z
Y X80 Approche proposée et résultats
concentration de A est augmentée au moment ti
, ou encore, con(A, down, tj) pour dire que la
concentration de A est diminuée au moment tj
. On est dans un cadre logique, donc il est
possible de représenter à peu près tout ce que l'on veut de manière naturelle. Le prix à payer,
si l’on utilise la totalité du langage peut être l'explosion combinatoire des algorithmes.
Les réactions entres métabolites sont une forme très simple de causalité. Pour exprimer
ces réactions, il est courant d'aller à l'essentiel en donnant deux relations binaires act(A, B) et
¬act(A, B). La première relation veut dire, par exemple, qu’un métabolite A est consommé
pour la production d'un métabolite B, la deuxième n’est pas consommé. De manière classique
ces relations sont représentées dans le réseau de gênes, par A → B et A ⊣ B. Bien entendu
cette causalité est élémentaire et de nombreux travaux très savants ont été écrits pour
représenter les causalités.
(C1) con(A,up,ti)∧react(A,B)∧active(A,B)∧react(B,C)∧non_active(B,C) → con(B,up,ti+1)
(C2) con(A,up,tj)∧react(A,B)∧non_active(A,B)∧react(B,C)∧active(B,C) → con(B,down,tj+1)
(C3) con(A,down,tk)∧ react(A,B)∧ active(A,B) → con(B,down,tk+1)
L’expression (C1) veut dire que si la concentration de A est augmentée au moment ti
, s’il
y a une réaction entre A et B dans laquelle le métabolite A est consumée pour la production du
métabolite B, et si pour toutes les réactions entre B et C le métabolite B n’est pas consommé
pour la production du métabolite C, alors la concentration de B est augmentée au moment ti+1.
L’expression (C2) veut dire que si la concentration de A est augmentée au moment tj
, s’il
y a une réaction entre A et B dans laquelle le métabolite A n’est pas consommé pour la
production du métabolite B, et si pour une réaction entre B et C le métabolite B est consommé
pour la production du métabolite C, alors la concentration de B est diminuée au moment tj+1.
L’expression (C3) veut dire que si la concentration de A est diminuée au moment tk, s’il y
a une réaction entre A et B dans laquelle le métabolite A est consommé pour la production du
métabolite B, alors la concentration de B est diminuée au moment tk+1.
Mais ces deux formulations posent problème dès qu'il y a un paradoxe. Si par exemple on
a un ensemble F de sept formules F = {con(A, up, ti), react(A, B), react(B, C), active(A, B),
non_active(B, C), non_active(A, B), active(B, C)}, alors on va dans les deux approches
données ci-dessus inféré de F, con(B, up, ti+1) et con(B, down, ti+1) ce qui est paradoxe, parce
que la concentration de B est augmentée et diminuée au même moment ti+1. Pour résoudre ce
conflit, on peut utiliser la logique des défauts.
Dans notre exemple, pour fournir des liens entre ces relations actives et non actives, l'idée
intuitive est donc d'affaiblir la formulation de règles de causalité:
(1) Si con(A,up,ti) , react(A,B), react(B,C), active(A,B), et non_active(B,C) sont vrais, et
s’il est possible que con(B,up,ti+1), alors con(B,up,ti+1) est conclu
(2) Si con(A,up,tj), react(A,B), react(B,C), non_active(A,B), et active(B,C) sont vrais, et
s’il est possible que con(B,down,tj+1), alors con(B,down,tj+1) est concluApproche proposée et résultats 81
(3) Si con(A,down,tk), react(A,B), et active(A,B) sont vrais, et s’il est possible que
con(B,down,tk+1), alors con(B,down,tk+1) est conclu
La question est alors de formellement décrire le possible. Dans la logique des défauts, les
règles (1), (2) et (3) seront exprimées de manière intuitive.
�1:
���(�, ��,��
) ∧ �����(�, �) ∧ �����(�, �) ∧ ������(�, �) ∧ ���_������(�, �): ���(�, ��,��+1)
���(�, ��,��+1)
�2:
�����, ��,��� ∧ �����(�, �) ∧ �����(�, �) ∧ ���_������(�, �) ∧ ������(�, �): ���(�, ����,��+1)
���(�, ����,��+1)
�3:
���(�, ����,��
) ∧ �����(�, �) ∧ ������(�, �): ���(�, ����,��+1)
���(�, ����,��+1)
Le paradoxe a été résolu.
Pour une théorie des défauts ∆ = (D, W), où D l'ensemble des défauts et W = {con(A, up,
t0)}, en utilisant l’algorithme de calcul des extensions, on a 12 extensions ci-dessous [27]:
EXTENSION 1:
joint(con(a,up, t0), act(a,b), non_act(b,c)) → con(b,up, t1)
joint(con(b,up, t1), act(b,d), non_act(d,e)) → con(d,up, t2)
joint(con(d,up, t2), act(d,e), non_act(e,c)) → con(e,up, t3)
joint(con(e,up, t3), act(e,c), non_act(c,b)) → con(c,up, t4)
EXTENSION 2:
joint(con(a,up, t0), act(a,b), non_act(b,c)) → con(b,up, t1)
joint(con(b,up, t1), act(b,d), non_act(d,e)) → con(d,up, t2)
joint(con(d,up, t2), act(d,e), non_act(e,c)) → con(e,up, t3)
joint(con(e,up, t3), non_act(e,c), act(c,b)) → con(c,down, t4)
EXTENSION 3:
joint(con(a,up, t0), act(a,b), non_act(b,c)) → con(b,up, t1)
joint(con(b,up, t1), act(b,d), non_act(d,e)) → con(d,up, t2)
joint(con(d,up, t2), non_act(d,e), act(e,c)) → con(e,down, t3)
joint(con(e,down, t3), act(e,c)) → con(c,down, t4)
EXTENSION 4:
joint(con(a,up, t0), act(a,b), non_act(b,c)) → con(b,up, t1)82 Approche proposée et résultats
joint(con(b,up, t1), non_act(b,d), act(d,e)) → con(d,down, t2)
joint(con(d,down, t2), act(d,e)) → con(e,down, t3)
joint(con(e,down, t3), act(e,c)) → con(c,down, t4)
EXTENSION 5:
joint(con(a,up, t0), non_act(a,b), act(b,c)) → con(b,down, t1)
joint(con(b,down, t1), act(b,c)) → con(c,down, t2)
joint(con(b,down, t1), act(b,d)) → con(d,down, t2)
joint(con(d,down, t2), act(d,e)) → con(e,down, t3)
EXTENSION 6:
joint(con(a,up, t0), non_act(a,b), act(b,c)) → con(b,down, t1)
joint(con(b,down, t1), act(b,d)) → con(d,down, t2)
joint(con(d,down, t2), act(d,e)) → con(e,down, t3)
joint(con(e,down, t3), act(e,c)) → con(c,down, t4)
EXTENSION 7:
joint(con(a,up, t0), act(a,b), non_act(b,d)) → con(b,up, t1)
joint(con(b,up, t1), act(b,d), non_act(d,e)) → con(d,up, t2)
joint(con(d,up, t2), act(d,e), non_act(e,c)) → con(e,up, t3)
joint(con(e,up, t3), act(e,c), non_act(c,b)) → con(c,up, t4)
EXTENSION 8:
joint(con(a,up, t0), act(a,b), non_act(b,d)) → con(b,up, t1)
joint(con(b,up, t1), act(b,d), non_act(d,e)) → con(d,up, t2)
joint(con(d,up, t2), act(d,e), non_act(e,c)) → con(e,up, t3)
joint(con(e,up, t3), non_act(e,c), act(c,b)) → con(c,down, t4)
EXTENSION 9:
joint(con(a,up, t0), act(a,b), non_act(b,d)) → con(b,up, t1)
joint(con(b,up, t1), act(b,d), non_act(d,e)) → con(d,up, t2)
joint(con(d,up, t2), non_act(d,e), act(e,c)) → con(e,down, t3)
joint(con(e,down, t3), act(e,c)) → con(c,down, t4)Approche proposée et résultats 83
EXTENSION 10:
joint(con(a,up, t0), act(a,b), non_act(b,d)) → con(b,up, t1)
joint(con(b,up, t1), non_act(b,d), act(d,e)) → con(d,down, t2)
joint(con(d,down, t2), act(d,e)) → con(e,down, t3)
joint(con(e,down, t3), act(e,c)) → con(c,down, t4)
EXTENSION 11:
joint(con(a,up, t0), non_act(a,b), act(b,d)) → con(b,down, t1)
joint(con(b,down, t1), act(b,c)) → con(c,down, t2)
joint(con(b,down, t1), act(b,d)) → con(d,down, t2)
joint(con(d,down, t2), act(d,e)) → con(e,down, t3)
EXTENSION 12:
joint(con(a,up, t0), non_act(a,b), act(b,d)) → con(b,down, t1)
joint(con(b,down, t1), act(b,d)) → con(d,down, t2)
joint(con(d,down, t2), act(d,e)) → con(e,down, t3)
joint(con(e,down, t3), act(e,c)) → con(c,down, t4)
Cet algorithme a une complexité très grande. Il sera sans doute nécessaire de réduire les
possibilités d'expression du langage pour arriver à des temps de calcul raisonnables. On
retrouve ici la même problématique que pour la résolution pratique des problèmes NPComplets.
Pour la carte de Pommier, après une coupe de l’algorithme pour réduire les
extensions équivalentes, on a la base de données et le résultat ci-dessous, où un fait w dans W
est défini « dur : --> w », et un défaut d = A:C/C dans D est défini « def : A --> C ».
LA BASE DE DONNÉES:
1 dur : --> phosphorylation(atr,h2ax)
2 dur : --> stimulation(dsb,dna)
3 def : stimulation(dsb,dna) --> product(altered_dna)
4 def : product(altered_dna) --> binding(mre11,rad50)
5 def : binding(mre11,rad50) --> product(mre11_rad50)
6 def : product(mre11_rad50) --> binding(mre11_rad50,nbs1)
7 def : binding(mre11_rad50,nbs1) --> product(mrn)
8 def : product(mrn) --> binding(mrn,altered_dna)
9 def : binding(mrn,altered_dna) --> product(mrn_bound_to_dna)
10 def : product(mrn_bound_to_dna) --> binding(mrn_bound_to_dna,atm_atm)
11 def : binding(mrn_bound_to_dna,atm_atm) --> product(atm_bound_to_mrn)
12 def : product(atm_bound_to_mrn) --> bloq-product(atm_atm)
13 def : product(atm_bound_to_mrn) --> autophosphorylation(atm_bound_to_mrn)
14 def : autophosphorylation(atm_bound_to_mrn) --> product(p_atm_atm_bound) 84 Approche proposée et résultats
15 def : product(p_atm_atm_bound) --> bloq-product(atm_atm)
16 def : product(p_atm_atm_bound) --> dissociation(p_atm_atm_bound)
17 def : dissociation(p_atm_atm_bound) --> product(p_atm_bound)
18 def : dissociation(p_atm_atm_bound) --> product(p_atm_free)
19 def : product(p_atm_free) --> phosphorylation(p_atm_free,chk1)
20 def : phosphorylation(p_atm_free,chk1) --> product(p_chk1)
21 dur : --> phosphorylation(atr,chk1)
22 def : phosphorylation(atr,chk1) --> product(p_chk1)
23 def : product(mrn_bound_to_dna) --> product(p_smc1)
24 def : product(mrn_bound_to_dna) --> product(p_mre11)
25 def : phosphorylation(atr,h2ax) --> product(gamma_h2ax)
26 def : phosphorylation(p_atm_bound,h2ax) --> product(gamma_h2ax)
27 def : product(gamma_h2ax) --> binding(gamma_h2ax,mdc1)
28 def : binding(gamma_h2ax,mdc1) --> product(h2ax_mdc1)
29 def : product(h2ax_mdc1) --> phosphorylation(p_atm_bound,h2ax_mdc1)
30 def : phosphorylation(p_atm_bound,h2ax_mdc1) --> product(p_mdc1)
31 def : product(p_mdc1) --> binding(p_mdc1,rnf8)
32 def : binding(p_mdc1,rnf8) --> product(rnf8_bound)
33 def : product(rnf8_bound) --> binding(rnf8_bound,ubc13)
34 def : binding(rnf8_bound,ubc13) --> product(rnf8_ubc13)
35 def : product(rnf8_ubc13) --> ubiquitination(rnf8_ubc13,h2a)
36 def : ubiquitination(rnf8_ubc13,h2a) --> product(ub_h2a)
37 def : product(ub_h2a) --> binding(ub_h2a,rnf168)
38 def : binding(ub_h2a,rnf168) --> product(rnf168_bound)
39 def : product(rnf168_bound) --> binding(rnf168_bound,ubc13)
40 def : binding(rnf168_bound,ubc13) --> product(rnf168_ubc13)
41 def : product(rnf168_ubc13) --> ubiquitination(rnf168_ubc13,h2a)
42 def : ubiquitination(rnf168_ubc13,h2a) --> product(poly_ub_h2a)
43 def : product(poly_ub_h2a) --> stimulation(poly_ub_h2a,dna)
44 def : stimulation(poly_ub_h2a,dna) --> product(changed_struct_dna)
45 def : product(poly_ub_h2a) --> binding(poly_ub_h2a,rap80)
46 def : binding(poly_ub_h2a,rap80) --> product(rap80_bound)
47 def : product(rap80_bound) --> binding(rap80_bound,abraxas)
48 def : binding(rap80_bound,abraxas) --> product(abraxas_bound)
49 def : product(abraxas_bound) --> binding(abraxas_bound,bre)
50 def : binding(abraxas_bound,bre) --> product(bre_bound)
51 def : product(abraxas_bound) --> binding(abraxas_bound,brcc36)
52 def : binding(abraxas_bound,brcc36) --> product(brcc36_bound)
53 def : product(brcc36_bound) --> binding(brcc36_bound,merit40)
54 def : binding(brcc36_bound,merit40) --> product(merit40_bound)
55 def : product(merit40_bound) --> binding(merit40_bound,brcc36_bound)
56 def : binding(merit40_bound,brcc36_bound) --> product(brcc36_merit40)
57 def : product(brcc36_merit40) --> binding(brcc36_merit40,brca1)
58 def : binding(brcc36_merit40,brca1) --> product(brca1_bound_to_rap80_complex)
59 def : product(changed_struct_dna) --> phosphorylation(p_atm_bound,mmset)
60 def : phosphorylation(p_atm_bound,mmset) --> product(p_mmset)
61 def : product(h2ax_mdc1) --> binding(h2ax_mdc1,mdc1)
62 def : binding(h2ax_mdc1,mdc1) --> product(mdc1_multi)Approche proposée et résultats 85
63 def : product(mdc1_multi), product(p_mmset) --> binding(mdc1_multi,p_mmset)
64 def : binding(mdc1_multi,p_mmset) --> product(mmset_mdc1)
65 def : product(mmset_mdc1) --> methylation(mmset_mdc1,h4)
66 def : methylation(mmset_mdc1,h4) --> product(h4k20me2)
67 def : product(h4k20me2), product(brca1_bound_to_rap80_complex) -->
binding(h4k20me2,p53bp1)
68 def : binding(h4k20me2,p53bp1) --> product(p53bp1_bound)
69 def : product(p53bp1_bound) --> phosphorylation(p_atm_bound,p53bp1_bound)
70 def : phosphorylation(p_atm_bound,p53bp1_bound) --> product(p_53bp1)
71 def : product(p_atm_free) --> phosphorylation(p_atm_free,plk3)
72 def : phosphorylation(p_atm_free,plk3) --> product(p_plk3)
73 def : product(p_atm_free) --> phosphorylation(p_atm_free,chk2)
74 def : phosphorylation(p_atm_free,chk2) --> product(p_s33_35_chk2)
75 def : product(p_s33_35_chk2) --> phosphorylation(p_plk3,p_s33_35_chk2)
76 def : phosphorylation(p_plk3,p_s33_35_chk2) --> product(p_s33_35_s62_73_chk2)
77 def : product(p_s33_35_s62_73_chk2) --> phosphorylation(p_atm_free,p_s33_35_s62_73_chk2)
78 def : phosphorylation(p_atm_free,p_s33_35_s62_73_chk2) --> product(p_t68_chk2)
79 def : product(p_s33_35_s62_73_chk2) --> phosphorylation(atr,p_s33_35_s62_73_chk2)
80 def : phosphorylation(atr,p_s33_35_s62_73_chk2) --> product(p_t68_chk2)
81 def : product(p_t68_chk2) --> binding(p_t68_chk2,p_t68_chk2)
82 def : binding(p_t68_chk2,p_t68_chk2) --> product(chk2_chk2)
83 def : product(chk2_chk2) --> autophosphorylation(chk2_chk2)
84 def : autophosphorylation(chk2_chk2) --> product(p_active_chk2_chk2)
85 def : product(p_active_chk2_chk2), product(p_53bp1) -->
binding(p_active_chk2_chk2,p_53bp1)
86 def : binding(p_active_chk2_chk2,p_53bp1) --> product(chk2_53bp1)
87 dur : --> binding(brca1,ctip)
88 def : binding(brca1,ctip) --> product(brca1_ctip)
89 def : product(brca1_ctip), product(chk2_53bp1) --> binding(brca1_ctip,chk2_53bp1)
90 def : binding(brca1_ctip,chk2_53bp1) --> product(chk2_53bp1_bound_to_brca1)
91 def : binding(brca1_ctip,chk2_53bp1) --> product(brca1_ctip_bound_to_chk2)
92 def : product(chk2_53bp1_bound_to_brca1), product(brca1_ctip_bound_to_chk2) -->
phosphorylation(chk2_53bp1_bound_to_brca1,brca1_ctip_bound_to_chk2)
93 def : phosphorylation(chk2_53bp1_bound_to_brca1,brca1_ctip_bound_to_chk2) -->
product(p_brca1_ctip_bound_to_chk2)
94 def : product(p_brca1_ctip_bound_to_chk2) --> product(p_s988_brca_ctip)
95 def : product(chk2_53bp1_bound_to_brca1) --> product(chk2_53bp1)
96 def : product(p_s988_brca_ctip) --> phosphorylation(p_atm_bound,p_s988_brca_ctip)
97 def : phosphorylation(p_atm_bound,p_s988_brca_ctip) --> product(brca_p_ctip)
98 def : product(brca_p_ctip) --> bloq-product(brca1_ctip)
99 def : product(brca_p_ctip) --> dissociation(brca_p_ctip)
100 def : dissociation(brca_p_ctip) --> product(brca1)
101 def : dissociation(brca_p_ctip) --> product(p_ctip)
102 def : product(brca1) --> phosphorylation(p_atm_bound,brca1)
103 def : phosphorylation(p_atm_bound,brca1) --> product(p_brca1)
104 def : product(brca1) --> phosphorylation(atr,brca1)
105 def : phosphorylation(atr,brca1) --> product(p_brca1)
106 def : product(p_brca1), product(p_53bp1) --> binding(mrn_bound_to_dna,p_brca1)86 Approche proposée et résultats
107 def : binding(mrn_bound_to_dna,p_brca1) --> product(brca1_bound_to_mrn)
108 def : product(chk2_53bp1) --> phosphorylation(chk2_53bp1,pml)
109 def : phosphorylation(chk2_53bp1,pml) --> product(p_pml)
110 def : product(p_pml) --> stimulation(p_pml,cell)
111 def : stimulation(p_pml,cell) --> product(apoptosis)
112 def : product(p_pml) --> binding(p_pml,mdm2)
113 def : binding(p_pml,mdm2) --> product(pml_mdm2)
114 def : product(pml_mdm2) --> bloq-binding(mdm2,p53)
115 dur : --> product(p53)
116 def : product(mdm2), product(p53) --> binding(mdm2,p53)
117 def : binding(mdm2,p53) --> product(mdm2_p53)
118 def : product(mdm2_p53) --> stimulation(p53_degradation_effectors,mdm2_p53)
119 def : stimulation(p53_degradation_effectors,mdm2_p53) --> product(p53_degradation)
120 def : product(p_atm_free), product(mdm2_p53) --> phosphorylation(p_atm_free,mdm2_p53)
121 def : phosphorylation(p_atm_free,mdm2_p53) --> product(p_s15_p53_mdm2)
122 def : product(mdm2_p53) --> phosphorylation(atr,mdm2_p53)
123 def : phosphorylation(atr,mdm2_p53) --> product(p_s15_p53_mdm2)
124 def : product(p_s15_p53_mdm2), product(chk2_53bp1) -->
phosphorylation(chk2_53bp1,p_s15_p53_mdm2)
125 def : phosphorylation(chk2_53bp1,p_s15_p53_mdm2) --> product(p_p_p53_mdm2)
126 def : product(p_s15_p53_mdm2), product(p_chk1) -->
phosphorylation(p_chk1,p_s15_p53_mdm2)
127 def : phosphorylation(p_chk1,p_s15_p53_mdm2) --> product(p_p_p53_mdm2)
128 def : product(p_s15_p53_mdm2) --> bloq-product(p53_degradation)
129 def : product(p_p_p53_mdm2) --> bloq-product(p53_degradation)
130 def : product(p_p_p53_mdm2) --> dissociation(p_p_p53_mdm2)
131 def : dissociation(p_p_p53_mdm2) --> product(p_p_p53)
132 def : dissociation(p_p_p53_mdm2) --> product(mdm2)
133 def : product(p_atm_free), product(mdm2) --> phosphorylation(p_atm_free,mdm2)
134 def : phosphorylation(p_atm_free,mdm2) --> product(p_mdm2)
135 def : product(p_p_p53) --> binding(p300,p_p_p53)
136 def : product(p_pml), binding(p300,p_p_p53) --> product(active_p53)
137 def : product(active_p53) --> transcription_activation(active_p53,prom_p21_gadd45)
138 def : transcription_activation(active_p53,prom_p21_gadd45) --> product(p21_and_gadd45)
139 def : product(prom_and_gadd45) --> stimulation(prom_and_gadd45,cell_cycle)
140 def : stimulation(p21_and_gadd45,cell_cycle) --> product(cell_cycle_arrest)
141 def : product(active_p53) --> transcription_activation(active_p53,prom_bnpf)
142 def : transcription_activation(active_p53,prom_bnpf) --> product(box_nas_puma_fas)
143 def : product(box_nas_puma_fas) --> stimulation(box_nas_puma_fas,cell)
144 def : stimulation(box_nas_puma_fas,cell) --> product(apoptosis)
145 def : product(active_p53) --> transcription_activation(active_p53,prom_mdm2)
146 def : transcription_activation(active_p53,prom_mdm2) --> product(mdm2)
147 dur : --> product(e2f1)
148 def : product(e2f1), product(chk2_53bp1) --> phosphorylation(chk2_53bp1,e2f1)
149 def : phosphorylation(chk2_53bp1,e2f1) --> product(p_e2f1)
150 def : product(e2f1) --> stimulation(e2f1_degradation_effectors,e2f1)
151 def : stimulation(e2f1_degradation_effectors,e2f1) --> product(e2f1_degradation)
152 def : product(p_e2f1) --> phosphorylation(p_atm_free,p_e2f1) Approche proposée et résultats 87
153 def : phosphorylation(p_atm_free,p_e2f1) --> product(p_p_e2f1)
154 def : product(p_e2f1) --> phosphorylation(atr,p_e2f1)
155 def : phosphorylation(atr,p_e2f1) --> product(p_p_e2f1)
156 def : product(p_p_e2f1) --> transcription_activation(p_p_e2f1,prom_chk2)
157 def : transcription_activation(p_p_e2f1,prom_chk2) --> product(chk2)
158 def : product(p_p_e2f1) --> transcription_activation(p_p_e2f1,prom_arf)
159 def : transcription_activation(p_p_e2f1,prom_arf) --> product(arf)
160 def : product(p_p_e2f1) --> transcription_activation(p_p_e2f1,prom_p73_apaf1)
161 def : transcription_activation(p_p_e2f1,prom_p73_apaf1) --> product(p73_apaf1)
162 def : product(p73_apaf1) --> stimulation(p73_apaf1,cell)
163 def : stimulation(p73_apaf1,cell) --> product(apoptosis)
164 def : product(arf) --> binding(arf,mdm2)
165 def : binding(arf,mdm2) --> product(arf_mdm2)
166 def : product(arf_mdm2) --> bloq-product(mdm2_p53)
167 def : product(p_p_e2f1) --> stimulation(p_p_e2f1,unknown_atm_way)
168 def : stimulation(p_p_e2f1,unknown_atm_way) --> product(p_atm_free)
169 def : product(p_atm_free) --> phosphorylation(p_atm_free,p38)
170 def : phosphorylation(p_atm_free,p38) --> product(p_p38)
171 def : product(chk2_53bp1) --> phosphorylation(chk2_53bp1,cdc25a)
172 def : phosphorylation(chk2_53bp1,cdc25a) --> product(p_cdc25a)
173 def : product(p_chk1) --> phosphorylation(p_chk1,cdc25a)
174 def : phosphorylation(p_chk1,cdc25a) --> product(p_cdc25a)
175 def : product(p_cdc25a) --> stimulation(cdc25a,cell)
176 def : stimulation(cdc25a,cell) --> bloq-product(cell_cycle_arrest)
177 def : product(p_cdc25a) --> stimulation(p_cdc25a,cdc25a_degradation_effectors)
178 def : stimulation(p_cdc25a,cdc25_degradation_effectors) --> product(cdc25a_degradation)
179 def : product(cdc25a_degradation) --> bloq-stimulation(cdc25a,cell)
180 def : product(chk2_53bp1) --> phosphorylation(chk2_53bp1,cdc25c)
181 def : phosphorylation(chk2_53bp1,cdc25c) --> product(p_cdc25c)
182 def : product(p_plk3) --> phosphorylation(p_plk3,cdc25c)
183 def : phosphorylation(p_plk3,cdc25c) --> product(p_cdc25c)
184 def : product(p_chk1) --> phosphorylation(p_chk1,cdc25c)
185 def : phosphorylation(p_chk1,cdc25c) --> product(p_cdc25c)
186 def : product(p_p38) --> phosphorylation(p_p38,cdc25c)
187 def : phosphorylation(p_p38,cdc25c) --> product(p_cdc25c)
188 def : product(p_cdc25c) --> stimulation(cdc25c,cell)
189 def : stimulation(cdc25c,cell) --> bloq-product(cell_cycle_arrest)
190 def : product(p_cdc25c) --> stimulation(p_cdc25c,cdc25c_degradation_effectors)
191 def : stimulation(cdc25b,cell) --> bloq-product(cell_cycle_arrest)
192 def : product(p_p38) --> phosphorylation(p_p38,cdc25b)
193 def : phosphorylation(p_p38,cdc25b) --> product(p_cdc25b)
194 def : product(p_cdc25b) --> bloq-stimulation(cdc25b,cell)
195 def : stimulation(jnk,cdc25c) --> product(p_cdc25c)
196 def : phosphorylation(jnk,p_s15_p53_mdm2) --> product(p_p_p53_mdm2)
197 def : product(p_atm_bound) --> phosphorylation(p_atm_bound,nbs1)
198 def : phosphorylation(p_atm_bound,nbs1) --> product(p_nbs1)
199 def : product(p_nbs1) --> phosphorylation(p_atm_bound,fancd2)
200 def : phosphorylation(p_atm_bound,fancd2) --> product(p_fancd2)88 Approche proposée et résultats
201 def : product(p_fancd2) --> stimulation(p_fancd2,cell)
202 def : stimulation(p_fancd2,cell) --> bloq-product(cell_cycle_arrest)
203 def : product(chk2_53bp1) --> binding(chk2_53bp1,mus81)
204 def : binding(chk2_53bp1,mus81) --> product(mus81_chk2)
205 def : product(mus81_chk2) --> binding(mus81_chk2,altered_dna)
206 def : binding(mus81_chk2,altered_dna) --> product(mus81_bound_to_dna)
LE RÉSULTAT
def 3 : (stimulation(dsb,dna), up, t0) ==> (product(altered_dna), up, t1)
def 4 : (product(altered_dna), up, t1) ==> (binding(mre11,rad50), up, t2)
def 5 : (binding(mre11,rad50), up, t2) ==> (product(mre11_rad50), up, t3)
def 6 : (product(mre11_rad50), up, t3) ==> (binding(mre11_rad50,nbs1), up, t4)
def 7 : (binding(mre11_rad50,nbs1), up, t4) ==> (product(mrn), up, t5)
def 8 : (product(mrn), up, t5) ==> (binding(mrn,altered_dna), up, t6)
def 9 : (binding(mrn,altered_dna), up, t6) ==> (product(mrn_bound_to_dna), up, t7)
def 10 : (product(mrn_bound_to_dna), up, t7) ==> (binding(mrn_bound_to_dna,atm_atm), up, t8)
def 11 : (binding(mrn_bound_to_dna,atm_atm), up, t8) ==> (product(atm_bound_to_mrn), up, t9)
def 12 : (product(atm_bound_to_mrn), up, t9) ==> (product(atm_atm), down, t10)
def 13 : (product(atm_bound_to_mrn), up, t9) ==> (autophosphorylation(atm_bound_to_mrn), up,
t10)
def 14 : (autophosphorylation(atm_bound_to_mrn), up, t10) ==> (product(p_atm_atm_bound), up,
t11)
def 16 : (product(p_atm_atm_bound), up, t11) ==> (dissociation(p_atm_atm_bound), up, t12)
def 17 : (dissociation(p_atm_atm_bound), up, t12) ==> (product(p_atm_bound), up, t13)
def 18 : (dissociation(p_atm_atm_bound), up, t12) ==> (product(p_atm_free), up, t13)
def 19 : (product(p_atm_free), up, t13) ==> (phosphorylation(p_atm_free,chk1), up, t14)
def 20 : (phosphorylation(p_atm_free,chk1), up, t14) ==> (product(p_chk1), up, t15)
def 23 : (product(mrn_bound_to_dna), up, t7) ==> (product(p_smc1), up, t8)
def 24 : (product(mrn_bound_to_dna), up, t7) ==> (product(p_mre11), up, t8)
def 25 : (phosphorylation(atr,h2ax), up, t0) ==> (product(gamma_h2ax), up, t1)
def 27 : (product(gamma_h2ax), up, t1) ==> (binding(gamma_h2ax,mdc1), up, t2)
def 28 : (binding(gamma_h2ax,mdc1), up, t2) ==> (product(h2ax_mdc1), up, t3)
def 29 : (product(h2ax_mdc1), up, t3) ==> (phosphorylation(p_atm_bound,h2ax_mdc1), up, t4)
def 30 : (phosphorylation(p_atm_bound,h2ax_mdc1), up, t4) ==> (product(p_mdc1), up, t5)
def 31 : (product(p_mdc1), up, t5) ==> (binding(p_mdc1,rnf8), up, t6)
def 32 : (binding(p_mdc1,rnf8), up, t6) ==> (product(rnf8_bound), up, t7)
def 33 : (product(rnf8_bound), up, t7) ==> (binding(rnf8_bound,ubc13), up, t8)
def 34 : (binding(rnf8_bound,ubc13), up, t8) ==> (product(rnf8_ubc13), up, t9)
def 35 : (product(rnf8_ubc13), up, t9) ==> (ubiquitination(rnf8_ubc13,h2a), up, t10)
def 36 : (ubiquitination(rnf8_ubc13,h2a), up, t10) ==> (product(ub_h2a), up, t11)
def 37 : (product(ub_h2a), up, t11) ==> (binding(ub_h2a,rnf168), up, t12)
def 38 : (binding(ub_h2a,rnf168), up, t12) ==> (product(rnf168_bound), up, t13)
def 39 : (product(rnf168_bound), up, t13) ==> (binding(rnf168_bound,ubc13), up, t14)
def 40 : (binding(rnf168_bound,ubc13), up, t14) ==> (product(rnf168_ubc13), up, t15)
def 41 : (product(rnf168_ubc13), up, t15) ==> (ubiquitination(rnf168_ubc13,h2a), up, t16)
def 42 : (ubiquitination(rnf168_ubc13,h2a), up, t16) ==> (product(poly_ub_h2a), up, t17)
def 43 : (product(poly_ub_h2a), up, t17) ==> (stimulation(poly_ub_h2a,dna), up, t18)
def 44 : (stimulation(poly_ub_h2a,dna), up, t18) ==> (product(changed_struct_dna), up, t19)
def 45 : (product(poly_ub_h2a), up, t17) ==> (binding(poly_ub_h2a,rap80), up, t18) Approche proposée et résultats 89
def 46 : (binding(poly_ub_h2a,rap80), up, t18) ==> (product(rap80_bound), up, t19)
def 47 : (product(rap80_bound), up, t19) ==> (binding(rap80_bound,abraxas), up, t20)
def 48 : (binding(rap80_bound,abraxas), up, t20) ==> (product(abraxas_bound), up, t21)
def 49 : (product(abraxas_bound), up, t21) ==> (binding(abraxas_bound,bre), up, t22)
def 50 : (binding(abraxas_bound,bre), up, t22) ==> (product(bre_bound), up, t23)
def 51 : (product(abraxas_bound), up, t21) ==> (binding(abraxas_bound,brcc36), up, t22)
def 52 : (binding(abraxas_bound,brcc36), up, t22) ==> (product(brcc36_bound), up, t23)
def 53 : (product(brcc36_bound), up, t23) ==> (binding(brcc36_bound,merit40), up, t24)
def 54 : (binding(brcc36_bound,merit40), up, t24) ==> (product(merit40_bound), up, t25)
def 55 : (product(merit40_bound), up, t25) ==> (binding(merit40_bound,brcc36_bound), up, t26)
def 56 : (binding(merit40_bound,brcc36_bound), up, t26) ==> (product(brcc36_merit40), up, t27)
def 57 : (product(brcc36_merit40), up, t27) ==> (binding(brcc36_merit40,brca1), up, t28)
def 58 : (binding(brcc36_merit40,brca1), up, t28) ==> (product(brca1_bound_to_rap80_complex),
up, t29)
def 59 : (product(changed_struct_dna), up, t19) ==> (phosphorylation(p_atm_bound,mmset), up,
t20)
def 60 : (phosphorylation(p_atm_bound,mmset), up, t20) ==> (product(p_mmset), up, t21)
def 61 : (product(h2ax_mdc1), up, t3) ==> (binding(h2ax_mdc1,mdc1), up, t4)
def 62 : (binding(h2ax_mdc1,mdc1), up, t4) ==> (product(mdc1_multi), up, t5)
def 63 : (product(mdc1_multi), up, t5), (product(p_mmset), up, t21) ==>
(binding(mdc1_multi,p_mmset), up, t22)
def 64 : (binding(mdc1_multi,p_mmset), up, t22) ==> (product(mmset_mdc1), up, t23)
def 65 : (product(mmset_mdc1), up, t23) ==> (methylation(mmset_mdc1,h4), up, t24)
def 66 : (methylation(mmset_mdc1,h4), up, t24) ==> (product(h4k20me2), up, t25)
def 67 : (product(h4k20me2), up, t25), (product(brca1_bound_to_rap80_complex), up, t29) ==>
(binding(h4k20me2,p53bp1), up, t30)
def 68 : (binding(h4k20me2,p53bp1), up, t30) ==> (product(p53bp1_bound), up, t31)
def 69 : (product(p53bp1_bound), up, t31) ==> (phosphorylation(p_atm_bound,p53bp1_bound), up,
t32)
def 70 : (phosphorylation(p_atm_bound,p53bp1_bound), up, t32) ==> (product(p_53bp1), up, t33)
def 71 : (product(p_atm_free), up, t13) ==> (phosphorylation(p_atm_free,plk3), up, t14)
def 72 : (phosphorylation(p_atm_free,plk3), up, t14) ==> (product(p_plk3), up, t15)
def 73 : (product(p_atm_free), up, t13) ==> (phosphorylation(p_atm_free,chk2), up, t14)
def 74 : (phosphorylation(p_atm_free,chk2), up, t14) ==> (product(p_s33_35_chk2), up, t15)
def 75 : (product(p_s33_35_chk2), up, t15) ==> (phosphorylation(p_plk3,p_s33_35_chk2), up, t16)
def 76 : (phosphorylation(p_plk3,p_s33_35_chk2), up, t16) ==> (product(p_s33_35_s62_73_chk2),
up, t17)
def 77 : (product(p_s33_35_s62_73_chk2), up, t17) ==>
(phosphorylation(p_atm_free,p_s33_35_s62_73_chk2), up, t18)
def 78 : (phosphorylation(p_atm_free,p_s33_35_s62_73_chk2), up, t18) ==> (product(p_t68_chk2),
up, t19)
def 79 : (product(p_s33_35_s62_73_chk2), up, t17) ==>
(phosphorylation(atr,p_s33_35_s62_73_chk2), up, t18)
def 81 : (product(p_t68_chk2), up, t19) ==> (binding(p_t68_chk2,p_t68_chk2), up, t20)
def 82 : (binding(p_t68_chk2,p_t68_chk2), up, t20) ==> (product(chk2_chk2), up, t21)
def 83 : (product(chk2_chk2), up, t21) ==> (autophosphorylation(chk2_chk2), up, t22)
def 84 : (autophosphorylation(chk2_chk2), up, t22) ==> (product(p_active_chk2_chk2), up, t23)
def 85 : (product(p_active_chk2_chk2), up, t23), (product(p_53bp1), up, t33) ==> 90 Approche proposée et résultats
(binding(p_active_chk2_chk2,p_53bp1), up, t34)
def 86 : (binding(p_active_chk2_chk2,p_53bp1), up, t34) ==> (product(chk2_53bp1), up, t35)
def 88 : (binding(brca1,ctip), up, t0) ==> (product(brca1_ctip), up, t1)
def 89 : (product(brca1_ctip), up, t1), (product(chk2_53bp1), up, t35) ==>
(binding(brca1_ctip,chk2_53bp1), up, t36)
def 90 : (binding(brca1_ctip,chk2_53bp1), up, t36) ==> (product(chk2_53bp1_bound_to_brca1), up,
t37)
def 91 : (binding(brca1_ctip,chk2_53bp1), up, t36) ==> (product(brca1_ctip_bound_to_chk2), up,
t37)
def 92 : (product(chk2_53bp1_bound_to_brca1), up, t37), (product(brca1_ctip_bound_to_chk2), up,
t37) ==>(phosphorylation(chk2_53bp1_bound_to_brca1,brca1_ctip_bound_to_chk2), up,
t38)
def 93 : (phosphorylation(chk2_53bp1_bound_to_brca1,brca1_ctip_bound_to_chk2), up, t38) ==>
(product(p_brca1_ctip_bound_to_chk2), up, t39)
def 94 : (product(p_brca1_ctip_bound_to_chk2), up, t39) ==> (product(p_s988_brca_ctip), up, t40)
def 96 : (product(p_s988_brca_ctip), up, t40) ==>
(phosphorylation(p_atm_bound,p_s988_brca_ctip), up, t41)
def 97 : (phosphorylation(p_atm_bound,p_s988_brca_ctip), up, t41) ==> (product(brca_p_ctip), up,
t42)
def 99 : (product(brca_p_ctip), up, t42) ==> (dissociation(brca_p_ctip), up, t43)
def 100 : (dissociation(brca_p_ctip), up, t43) ==> (product(brca1), up, t44)
def 101 : (dissociation(brca_p_ctip), up, t43) ==> (product(p_ctip), up, t44)
def 102 : (product(brca1), up, t44) ==> (phosphorylation(p_atm_bound,brca1), up, t45)
def 103 : (phosphorylation(p_atm_bound,brca1), up, t45) ==> (product(p_brca1), up, t46)
def 104 : (product(brca1), up, t44) ==> (phosphorylation(atr,brca1), up, t45)
def 106 : (product(p_brca1), up, t46), (product(p_53bp1), up, t33) ==>
(binding(mrn_bound_to_dna,p_brca1), up, t47)
def 107 : (binding(mrn_bound_to_dna,p_brca1), up, t47) ==> (product(brca1_bound_to_mrn), up,
t48)
def 108 : (product(chk2_53bp1), up, t35) ==> (phosphorylation(chk2_53bp1,pml), up, t36)
def 109 : (phosphorylation(chk2_53bp1,pml), up, t36) ==> (product(p_pml), up, t37)
def 110 : (product(p_pml), up, t37) ==> (stimulation(p_pml,cell), up, t38)
def 111 : (stimulation(p_pml,cell), up, t38) ==> (product(apoptosis), up, t39)
def 112 : (product(p_pml), up, t37) ==> (binding(p_pml,mdm2), up, t38)
def 113 : (binding(p_pml,mdm2), up, t38) ==> (product(pml_mdm2), up, t39)
def 114 : (product(pml_mdm2), up, t39) ==> (binding(mdm2,p53), down, t40)
def 148 : (product(e2f1), up, t0), (product(chk2_53bp1), up, t35) ==>
(phosphorylation(chk2_53bp1,e2f1), up, t36)
def 149 : (phosphorylation(chk2_53bp1,e2f1), up, t36) ==> (product(p_e2f1), up, t37)
def 150 : (product(e2f1), up, t0) ==> (stimulation(e2f1_degradation_effectors,e2f1), up, t1)
def 151 : (stimulation(e2f1_degradation_effectors,e2f1), up, t1) ==> (product(e2f1_degradation), up,
t2)
def 152 : (product(p_e2f1), up, t37) ==> (phosphorylation(p_atm_free,p_e2f1), up, t38)
def 153 : (phosphorylation(p_atm_free,p_e2f1), up, t38) ==> (product(p_p_e2f1), up, t39)
def 154 : (product(p_e2f1), up, t37) ==> (phosphorylation(atr,p_e2f1), up, t38)
def 156 : (product(p_p_e2f1), up, t39) ==> (transcription_activation(p_p_e2f1,prom_chk2), up, t40)
def 157 : (transcription_activation(p_p_e2f1,prom_chk2), up, t40) ==> (product(chk2), up, t41)
def 158 : (product(p_p_e2f1), up, t39) ==> (transcription_activation(p_p_e2f1,prom_arf), up, t40) Approche proposée et résultats 91
def 159 : (transcription_activation(p_p_e2f1,prom_arf), up, t40) ==> (product(arf), up, t41)
def 160 : (product(p_p_e2f1), up, t39) ==> (transcription_activation(p_p_e2f1,prom_p73_apaf1),
up, t40)
def 161 : (transcription_activation(p_p_e2f1,prom_p73_apaf1), up, t40) ==> (product(p73_apaf1),
up, t41)
def 162 : (product(p73_apaf1), up, t41) ==> (stimulation(p73_apaf1,cell), up, t42)
def 164 : (product(arf), up, t41) ==> (binding(arf,mdm2), up, t42)
def 165 : (binding(arf,mdm2), up, t42) ==> (product(arf_mdm2), up, t43)
def 166 : (product(arf_mdm2), up, t43) ==> (product(mdm2_p53), down, t44)
def 167 : (product(p_p_e2f1), up, t39) ==> (stimulation(p_p_e2f1,unknown_atm_way), up, t40)
def 169 : (product(p_atm_free), up, t13) ==> (phosphorylation(p_atm_free,p38), up, t14)
def 170 : (phosphorylation(p_atm_free,p38), up, t14) ==> (product(p_p38), up, t15)
def 171 : (product(chk2_53bp1), up, t35) ==> (phosphorylation(chk2_53bp1,cdc25a), up, t36)
def 172 : (phosphorylation(chk2_53bp1,cdc25a), up, t36) ==> (product(p_cdc25a), up, t37)
def 173 : (product(p_chk1), up, t15) ==> (phosphorylation(p_chk1,cdc25a), up, t16)
def 175 : (product(p_cdc25a), up, t37) ==> (stimulation(cdc25a,cell), up, t38)
def 176 : (stimulation(cdc25a,cell), up, t38) ==> (product(cell_cycle_arrest), down, t39)
def 177 : (product(p_cdc25a), up, t37) ==> (stimulation(p_cdc25a,cdc25a_degradation_effectors),
up, t38)
def 180 : (product(chk2_53bp1), up, t35) ==> (phosphorylation(chk2_53bp1,cdc25c), up, t36)
def 181 : (phosphorylation(chk2_53bp1,cdc25c), up, t36) ==> (product(p_cdc25c), up, t37)
def 182 : (product(p_plk3), up, t15) ==> (phosphorylation(p_plk3,cdc25c), up, t16)
def 184 : (product(p_chk1), up, t15) ==> (phosphorylation(p_chk1,cdc25c), up, t16)
def 186 : (product(p_p38), up, t15) ==> (phosphorylation(p_p38,cdc25c), up, t16)
def 188 : (product(p_cdc25c), up, t37) ==> (stimulation(cdc25c,cell), up, t38)
def 190 : (product(p_cdc25c), up, t37) ==> (stimulation(p_cdc25c,cdc25c_degradation_effectors),
up, t38)
def 192 : (product(p_p38), up, t15) ==> (phosphorylation(p_p38,cdc25b), up, t16)
def 193 : (phosphorylation(p_p38,cdc25b), up, t16) ==> (product(p_cdc25b), up, t17)
def 194 : (product(p_cdc25b), up, t17) ==> (stimulation(cdc25b,cell), down, t18)
def 197 : (product(p_atm_bound), up, t13) ==> (phosphorylation(p_atm_bound,nbs1), up, t14)
def 198 : (phosphorylation(p_atm_bound,nbs1), up, t14) ==> (product(p_nbs1), up, t15)
def 199 : (product(p_nbs1), up, t15) ==> (phosphorylation(p_atm_bound,fancd2), up, t16)
def 200 : (phosphorylation(p_atm_bound,fancd2), up, t16) ==> (product(p_fancd2), up, t17)
def 201 : (product(p_fancd2), up, t17) ==> (stimulation(p_fancd2,cell), up, t18)
def 203 : (product(chk2_53bp1), up, t35) ==> (binding(chk2_53bp1,mus81), up, t36)
def 204 : (binding(chk2_53bp1,mus81), up, t36) ==> (product(mus81_chk2), up, t37)
def 205 : (product(mus81_chk2), up, t37) ==> (binding(mus81_chk2,altered_dna), up, t38)
def 206 : (binding(mus81_chk2,altered_dna), up, t38) ==> (product(mus81_bound_to_dna), up, t39)
Ce résultat est représenté dans la Figure 4.7. Les chiffres rouges sont les défauts utilisés
dans le résultat.92 Approche proposée et résultats
Figure 4.7. Une extension de la carte de PommierConclusion 93
Conclusion
Les voies de signalisation sont très importantes pour la compréhension des mécanismes
des fonctions biologiques.
Cette thèse étudie la synthèse automatique des voies de signalisation à partir
d’informations trouvées dans des bases de connaissances. Une composante essentielle de
cette approche est l’utilisation du raisonnement logique pour représenter la connaissance
biologique de la communication intracellulaire. En choisissant la représentation adéquate des
connaissances biologiques la partie « raisonnement » est capable d’assigner un ordre dans
l’acquisition des faits et d’extraire les interactions nécessaires à la synthèse des voies
métaboliques ou de signalisation.
La première partie de la thèse est consacrée à la synthèse des voies pharmaco-cinétiques
par des algorithmes de production. Cet algorithme est décidable, cohérent et complet. La
deuxième partie utilise la logique des défauts pour représenter les interactions dans les
réseaux de gènes.
Le problème de l'implémentation et de la complexité algorithmique n'a pas été abordé. Il
sera sans doute nécessaire de réduire les possibilités d'expression du langage pour arriver à
des temps de calcul raisonnables. On retrouve ici la même problématique que pour la
résolution pratique des problèmes NP-Complets. Bien entendu le problème est ici plus
compliqué. La complexité pratique peut alors rester accessible en contrôlant l'écriture des
règles. Par exemple dans un premier temps on peut essayer de se restreindre à quelque chose
qui ressemble à des clauses de Horn (clauses qui contiennent au plus un littéral positif [2]). Bibliographie 95
Bibliographie
[1] Demongeot J, “Multi-stationarity and cell differentiation”, J. Biol. Systems., 6, 1-2 (1998).
[2] Doncescu A. , Inoue K. and Yamamoto, “Knowledge-based discovery in systems biology using
CF-induction”. New Trends in Applied Artificial Intelligence: Proceedings of the 20th
International Conference on Industrial, Engineering and Other Applications of Applied Intelligent
Systems (IEA / AIE 2007), Lecture Notes in Artificial Intelligence, volume 4570, pages 395-404,
Springer-Verlag.
[3] Doncescu A, and Siegel P, “Utilisation de la logique des hypothèses pour la modélisation des
voies de signalisation dans la cellule”, JIAF 11, Lyon 8-10, June 2011.
[4] Doncescu A., Waissman J.,Richard G.,Roux G. “Characterization of bio-chemical signals by
inductive logic programming”, Knowledge-Based Systems 15 (1), 129-137, 2002.
[5] Christophe Chassagnole, Juan Carlos, A Rodriguez, Andrei Doncescu, Laurence T Yang
“Differential evolutionary algorithms for in vivo dynamic analysis of glycolysis and pentose
phosphate pathway in Escherichia Coli”, Parallel Computing for Bioinformatics and
Computational Biology: Models, Enabling Technologies, and Case Studies, 59-78, John Wiley &
Sons, Inc.,2006.
[6] Montseny E., Doncescu A., “Operatorial Parametrizing of Controlled Dynamic SystemsApplication
to the Fed-Batch Bioreactor Control Problem”, 17th World Congress The
International Federation of Automatic Control. Seoul, Korea, June 2008.
[7] Forget L, Rish V. , P Siegel. “Preferential Logics are X-logics” Journal of Computational Logic,
10, 2000, pp. 1-13.
[8] Ginsberg, ML, Smith, DE (July 1988). “Reasoning about action II: the qualification problem”.
Artificial Intelligence Vol. 35 No. 3 pp.311-342.
[9] Giunchiglia, E., Lee, J., Lifschitz, V., McCain, N., & Turner, H. (March 2004). “Nonmonotonic
causal theories”. Artificial Intelligence No. 1-2 vol.153 pp.49-104.
[10]Inoue K, “Induction as Consequence Finding”. Machine Learning, 55 (2) :109-135, 2004.
[11]Inoue K, Saito H. “Circumscripta Policies for Induction” Proceedings of 14th Conf. on Inductive
Logic Programming, LNAI 3194, pp.164-179, Springer, September 2004.
[12]K. Inoue, T. Sato, M. Ishihata, Y. Kameya and H. Nabeshima, “Evaluating abductive hypotheses
using an em algorithm on bdds”, in: Proceedings of IJCAI-09, Pasadena, CA, 2009, pp. 810–815.
[13]Kayser D., Levy F. “Modeling symbolic causal reasoning”, Intellecta 2004 / 1, 38, pp 291-232
[14]Nabeshima H. , Iwanuma K., Inoue K. Ray O. “SOLAR: An automated deduction system for
Finding consequence”. AI Commun. 23 (2-3): 183-203 (2010)
[15]Roux-Rouquié M., L. Hood, Imbeaud S., Auffray C. “Issues in Computational Methods for
Functional Genomics and Systems Biology”. CMSB 2003 : 182-186
[16]Schwind P. , Siegel P: “Modal Logic for Hypothesis Theory”, Fundamentae Informaticae, cal 21,
No. 1-2 89-101.
[17]Synnaeve G, Inoue K, Doncescu A, Nabeshima N, Kameya Y, Ishihata M., Sato T, “Kinetic
models and qualitative abstraction for relational learning in systems biology”, BIOSTEC
Bioinformatics 2011
[18]Siegel P. : “A modal language for Nonmonotonic Reasonning”, Proc. Workshop DRUMS / EEC
Marseille 24-27 February 90.
[19]P. Siegel , C. Schwind, “Modal logic based theory for nonmonotonic reasoning”. Journal of
Applied Non-classical Logic, Volume 3 - No. 1 / 1993, P 73-92.
[20]Synnaeve G., Doncescu A., Inoue K., “Kinetic models for logic-based hypothesis finding in
metabolic pathways”, Int’l Conf. on Inductive Logic Programming (ILP-09), 2009.
[21]Tran N. , C. Baral (2007) “Hypothesizing and reasoning about signaling networks”. Journal of
Applied Logic 7 (2009) 253-274 96 Bibliographie
[22]Barthélémy DWORKIN “Utilisation de SOLAR dans la voie de signalisation ATM-dépendante de
la cassure double-brin de l'ADN”. Mémoire de master 2 / Université Paul Sabatier, Toulouse
2011.
[23]Toulgoat I. “Modélisation du comportement humain dans les simulations de combat naval”. Thèse
doctorat / Université du Sud, Toulon-Var [s.n] 2011.
[24]Pommier Y et al. “Targeting Chk2 kinase: Molecular interaction maps and therapeutic rationale”.
2005
[25]Munna L. Agarwal et al. “The p53 Network”, Journal of Biological Chemistry, Vol. 273, No 1,
Issue of January 2, pp. 1-4, 1998
[26]P. Siegel, “Représentation et utilization de la connaissance en calcul propositionnel”, Thèse
d’État, Université d’Aix-Marseille II, Luminy, France, 1987.
[27]Tan Le, A. Doncescu, P. Siegel, “Default Logic for Diagnostic of Discrete Time System”, 8th
international conference BWCCA, October 28-30 2013, Compiegne, France, pp. 488-493.
[28]Tan Le, A. Doncescu, P. Siegel, “Utilization of Default Logic for Analyzing a Metabolic System
in Discrete Time”, 13th international conference ICCSA, June 24-27 2013, Ho Chi Minh City,
Vietnam, pp. 130-136.
[29]G. Bossu, P. Siegel, “Nonmonotonic Reasoning and databases”, Workshop Logic and Data Bases.
CERT - Toulouse - Décembre 1982
[30]G. Bossu, P. Siegel, “Saturation, Nonmonotonic Reasoning and the Closed World Assumption”,
Artificial Intelligence 25, Janvier 1985, p. 13-63
[31]J.M. Boi, E. Innocenti, A. Rauzy, P. Siegel, “Production Fields : a New approach to Deduction
Problems and two Algorithms for propositional Calculus”, Revue d'Intelligence Artificielle, vol 6
- n° 3/1992 , p 235, 255.
Equilibrage de charge dynamique avec un nombre ´
variable de processeurs bas´e sur des m´ethodes de
partitionnement de graphe
Cl´ement Vuchener
To cite this version:
Cl´ement Vuchener. Equilibrage de charge dynamique avec un nombre variable de processeurs ´
bas´e sur des m´ethodes de partitionnement de graphe. Distributed, Parallel, and Cluster Computing.
Universit´e de Bordeaux, 2014. French.
HAL Id: tel-00952777
https://tel.archives-ouvertes.fr/tel-00952777
Submitted on 27 Feb 2014
HAL is a multi-disciplinary open access
archive for the deposit and dissemination of scientific
research documents, whether they are published
or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.
L’archive ouverte pluridisciplinaire HAL, est
destin´ee au d´epˆot et `a la diffusion de documents
scientifiques de niveau recherche, publi´es ou non,
´emanant des ´etablissements d’enseignement et de
recherche fran¸cais ou ´etrangers, des laboratoires
publics ou priv´es.THESE
`
PRESENT ´ EE´ A`
L’UNIVERSITE DE BORDEAUX ´
ECOLE DOCTORALE DE MATH ´ EMATIQUES ET ´
D’INFORMATIQUE
Par Cl´ement VUCHENER
POUR OBTENIR LE GRADE DE
DOCTEUR
SPECIALIT ´ E : INFORMATIQUE ´
Equilibrage de charge dynamique avec un nombre ´
variable de processeurs bas´e sur des m´ethodes de
partitionnement de graphe
Soutenue le : 7 f´evrier 2014
Apr`es avis des rapporteurs :
Pierre Manneback Professeur
Bora U¸car . . . . . . . . Charg´e de Recherche
Devant la commission d’examen compos´ee de :
Florent Duchaine . Senior Researcher . . . . Examinateur
Aur´elien Esnard . . Maˆıtre de Conf´erences Directeur de Th`ese
Pierre Manneback Professeur . . . . . . . . . . . . Pr´esident du Jury & Rapporteur
Fran¸cois Pellegrini Professeur . . . . . . . . . . . . Examinateur
Jean Roman . . . . . Professeur . . . . . . . . . . . . Directeur de Th`ese
Bora U¸car . . . . . . . . Charg´e de Recherches Rapporteur
2014iiiii
Remerciements
Avant tout, je remercie mes directeurs de th`ese Jean Roman et Aur´elien Esnard qui ont
accept´e d’encadrer cette th`ese. Et plus particuli`erement Aur´elien pour tout le temps qu’il m’a
accord´e, ces longues discussions qui ont permis `a cette th`ese d’avancer et tous les conseils donn´es.
Je remercie Pierre Manneback et Bora U¸car qui ont accept´e de rapporter cette th`ese malgr´e
des d´elais tr`es courts, ainsi que les autres membres du jury : Fran¸cois Pellegrini et Florent
Duchaine pour l’int´erˆet port´e `a mes travaux.
Je remercie ´egalement S´ebastien Fourestier et, encore une fois, Fran¸cois Pellegrini pour toute
leur aide sur Scotch et comment y ajouter ma m´ethode de partitionnement.
Je remercie toute l’´equipe INRIA HiePACS au sein de laquelle j’ai effectu´e cette th`ese et plus
particuli`erement les autres doctorants de l’´equipe qui m’ont tenu compagnie pendant pr`es de
trois ans pour certains.ivv
Equilibrage de charge dynamique avec un nombre variable ´
de processeurs bas´e sur des m´ethodes de partitionnement
de graphe
R´esum´e
L’´equilibrage de charge est une ´etape importante conditionnant les performances des applications
parall`eles. Dans le cas o`u la charge varie au cours de la simulation, il est important de
redistribuer r´eguli`erement la charge entre les diff´erents processeurs. Dans ce contexte, il peut
s’av´erer pertinent d’adapter le nombre de processeurs au cours d’une simulation afin d’obtenir
une meilleure efficacit´e, ou de continuer l’ex´ecution quand toute la m´emoire des ressources
courantes est utilis´ee. Contrairement au cas o`u le nombre de processeurs ne varie pas, le r´e´equilibrage
dynamique avec un nombre variable de processeurs est un probl`eme peu ´etudi´e que nous
abordons ici.
Cette th`ese propose diff´erentes m´ethodes bas´ees sur le repartitionnement de graphe pour
r´e´equilibrer la charge tout en changeant le nombre de processeurs. Nous appelons ce probl`eme
« repartitionnement M × N ». Ces m´ethodes se d´ecomposent en deux grandes ´etapes. Dans un
premier temps, nous ´etudions la phase de migration et nous construisons une « bonne » matrice
de migration minimisant plusieurs crit`eres objectifs comme le volume total de migration et le
nombre total de messages ´echang´es. Puis, dans un second temps, nous utilisons des heuristiques
de partitionnement de graphe pour calculer une nouvelle distribution optimisant la migration en
s’appuyant sur les r´esultats de l’´etape pr´ec´edente. En outre, nous proposons un algorithme de
partitionnement k-aire direct permettant d’am´eliorer le partitionnement biais´e. Finalement, nous
validons cette th`ese par une ´etude exp´erimentale en comparant nos m´ethodes aux partitionneurs
actuels.
Mots-cl´es
Simulation num´erique, parall´elisme, ´equilibrage de charge dynamique, redistribution, partitionnement
de graphe, repartitionnement.vi
Dynamic Load-Balancing with Variable Number of Processors
based on Graph Partitioning
Abstract
Load balancing is an important step conditioning the performance of parallel programs. If
the workload varies drastically during the simulation, the load must be redistributed regularly
among the processors. Dynamic load balancing is a well studied subject but most studies are
limited to an initially fixed number of processors. Adjusting the number of processors at runtime
allows to preserve the parallel code efficiency or to keep running the simulation when the memory
of the current resources is exceeded.
In this thesis, we propose some methods based on graph repartitioning in order to rebalance
the load while changing the number of processors. We call this problem “M × N repartitioning”.
These methods are split in two main steps. Firstly, we study the migration phase and we
build a “good” migration matrix minimizing several metrics like the migration volume or the
number of exchanged messages. Secondly, we use graph partitioning heuristics to compute a new
distribution optimizing the migration according to the previous step results. Besides, we propose
a direct k-way partitioning algorithm that allows us to improve our biased partitioning. Finally,
an experimental study validates our algorithms against state-of-the-art partitioning tools.
Keywords
Numerical simulation, parallelism, dynamic load-balancing, redistribution, graph partitioning,
repartitioning.Table des mati`eres
1 Introduction 1
2 Etat de l’art ´ 5
2.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Partitionnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2.1 Mod´elisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2.2 M´ethodes de partitionnement de graphe . . . . . . . . . . . . . . . . . . . 9
2.2.3 Etat de l’art des outils de partitionnement . . . . . . . . . . . . . . . . . . 11 ´
2.3 Repartitionnement pour l’´equilibrage dynamique . . . . . . . . . . . . . . . . . . 13
2.3.1 Mod´elisation du probl`eme de repartitionnement . . . . . . . . . . . . . . . 13
2.3.2 M´ethodes de repartitionnement de graphe . . . . . . . . . . . . . . . . . . 14
2.4 Positionnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3 Mod`ele de migration pour le repartitionnement M × N 25
3.1 Notations et d´efinitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.1.1 G´en´eralit´es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.1.2 D´efinitions pour le repartitionnement M × N . . . . . . . . . . . . . . . . 27
3.2 Matrices de migration optimales dans le cas ´equilibr´e . . . . . . . . . . . . . . . . 28
3.3 Construction des matrices de migration . . . . . . . . . . . . . . . . . . . . . . . 35
3.3.1 M´ethode bas´ee sur la chaˆıne (1D) . . . . . . . . . . . . . . . . . . . . . . . 35
3.3.2 M´ethode d’appariement (Matching) . . . . . . . . . . . . . . . . . . . . . 42
3.3.3 M´ethode gloutonne (Greedy) . . . . . . . . . . . . . . . . . . . . . . . . . 47
3.3.4 Programme lin´eaire (LP) . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
3.4 Evaluation des m´ethodes et conclusion . . . . . . . . . . . . . . . . . . . . . . ´ . . 62
4 Repartitionnement M × N 67
4.1 Repartitionnement M × N bas´e sur le partitionnement biais´e (BIASED) . . . . . 67
4.1.1 M´ethodologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
4.1.2 Limitations des partitionneurs . . . . . . . . . . . . . . . . . . . . . . . . 71
4.2 Partitionnement k-aire direct (KGGGP) . . . . . . . . . . . . . . . . . . . . . . . 73
4.2.1 Description de l’algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . 73
4.2.2 Crit`eres de s´election . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.2.3 Complexit´e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
4.2.4 Am´eliorations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
4.2.5 Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 ´
4.3 Repartitionnement M × N bas´e sur la diffusion (DIFF) . . . . . . . . . . . . . . 85
4.4 Partitionnement biais´e `a l’aide d’hyper-arˆetes de repartitionnement . . . . . . . . 89
4.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
viiviii TABLE DES MATIERES `
5 R´esultats 91
5.1 M´ethodologie exp´erimentale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
5.2 Influence du coˆut de migration et du facteur de repartitionnement . . . . . . . . 94
5.3 Influence du nouveau nombre de processeurs . . . . . . . . . . . . . . . . . . . . . 97
5.4 Comparaison sur des graphes complexes . . . . . . . . . . . . . . . . . . . . . . . 101
5.5 Etude de la complexit´e en temps . . . . . . . . . . . . . . . . . . . . . . . . . ´ . . 110
6 Conclusion et Perspectives 115
6.1 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
6.2 Perspectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
A Programmes lin´eaires pour optimiser les diff´erentes m´etriques 119
A.1 Minimisation de TotalV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
A.2 Minimisation de MaxV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
A.3 Minimisation de TotalZ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
A.4 Minimisation de MaxZ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
B Documentation du KGGGP dans Scotch 123
C R´esultats suppl´ementaires 125
C.1 Influence du coˆut de migration et du facteur de repartitionnement . . . . . . . . 125
C.2 Comparaison sur des graphes complexes . . . . . . . . . . . . . . . . . . . . . . . 126
Bibliographie 133
Liste des publications 137Chapitre 1
Introduction
Une simulation num´erique mod´elise g´en´eralement l’´evolution en temps d’un ph´enom`ene physique
dans un domaine de l’espace. Souvent, on utilise un sch´ema it´eratif en temps et une discr´etisation
de l’espace via un maillage d’´el´ements g´eom´etriques (triangles, carr´es, t´etra`edres, etc.).
Des simulations de plus en plus complexes demandent une plus grande puissance de calcul. Pour
cela, ces applications doivent fonctionner en parall`ele sur plusieurs nœuds de calcul. Les donn´ees
sont alors r´eparties sur les diff´erentes unit´es de traitement ou « processeurs ». Les processeurs
ne pouvant pas acc´eder directement et rapidement aux donn´ees des autres processeurs, ce parall´elisme
induit un surcout dˆu aux communications sur le r´eseau. La m´emoire ´etant distribu´ee, la
r´epartition des calculs implique une distribution des donn´ees.
Dans ce contexte, la distribution des donn´ees est une ´etape importante conditionnant les
performances d’une simulation num´erique et elle est faite selon deux objectifs :
— la charge de calcul affect´ee aux diff´erents processeurs doit ˆetre ´equilibr´ee pour minimiser
le temps de calcul de chacun ;
— les communications inter-processeurs induites par la distribution doivent ˆetre minimis´ees.
Certaines simulations num´eriques complexes ont une charge de calcul qui peut ´evoluer de fa¸con
impr´evisible ; c’est le cas par exemple des simulations de type AMR (Adaptive Mesh Refinement)
o`u la discr´etisation de l’espace ´evolue pour ˆetre plus fine autour de points d’int´erˆet. La charge de
certains processeurs peut augmenter plus rapidement que d’autres et il n’est alors plus possible de
garder une mˆeme distribution tout le long de la simulation. De nouvelles distributions doivent ˆetre
recalcul´ees pour r´e´equilibrer la charge lorsque le d´es´equilibre devient trop important. On parle
alors d’´equilibrage dynamique. En plus des deux objectifs pr´ec´edents, la nouvelle distribution doit
r´epondre `a deux nouvelles contraintes :
— la nouvelle partition doit ˆetre calcul´ee rapidement en parall`ele ;
— la migration des donn´ees n´ecessaire pour passer de l’ancienne distribution `a la nouvelle
doit ˆetre la plus rapide possible, c’est-`a-dire qu’il faut que le moins possible de donn´ees
ne change de processeurs.
Le probl`eme de calcul de telles distributions peut ˆetre r´esolu `a l’aide du partitionnement d’un
graphe non-orient´e en k parties. Les sommets du graphe repr´esentent les calculs et les arˆetes
repr´esentent les d´ependances entre ces calculs. Chaque partie repr´esente l’ensemble des calculs
affect´es `a un processeur. Deux sommets connect´es qui se trouvent dans deux parties diff´erentes (on
dira que l’arˆete est coup´ee) induisent un besoin de communication entre ces deux processeurs.
L’objectif de la distribution devient alors de construire une partition dont les parties sont de
mˆeme taille et coupant un minimum d’arˆetes. Dans le cas de l’´equilibrage dynamique, on parlera
de « repartitionnement ». Le partitionnement de graphe est un probl`eme d´ej`a bien ´etudi´e, que
12 CHAPITRE 1. INTRODUCTION
ce soit dans le cas statique o`u une seule partition est calcul´ee, ou dynamique o`u la partition est
recalcul´ee r´eguli`erement.
Augmentation
de la charge
M = 4 N = 6
Figure 1.1 – Allocation dynamique de processeurs pour un code parall`ele dont la charge augmente.
Lorsque la charge de calcul varie de fa¸con importante, il peut devenir int´eressant de changer
le nombre de processeurs allou´es. Cela peut permettre de continuer la simulation quand toute
la m´emoire des processeurs est utilis´ee, ou ainsi d’am´eliorer la consommation des ressources
pour garder une bonne efficacit´e au cours de la simulation. Par exemple, un code AMR utilise
initialement un maillage tr`es simple avec peu d’´el´ements, qu’il ne serait pas efficace de distribuer
sur un grand nombre de processeurs. Avec le raffinement du maillage, la quantit´e de calcul
augmente de fa¸con importante, et la parall´elisation sur un plus grande nombre de processeurs
devient plus int´eressante, voire n´ecessaire si la taille du probl`eme d´epasse la capacit´e m´emoire
des processeurs d´ej`a allou´es. Il faut alors ˆetre capable de calculer une nouvelle distribution pour
un plus grand nombre de processeurs, comme illustr´e en figure 1.1.
Augmentation de la
charge relative A/B
M + M' = 6 N + N' = 6
A B A B
Figure 1.2 – Allocation dynamique de processeurs pour deux codes coupl´es A et B dont la
charge relative de A par rapport `a B augmente.
L’allocation dynamique de processeurs est ´egalement utile dans le cas des codes coupl´es. Ce
sont diff´erents codes s’ex´ecutant en parall`ele et collaborant pour r´ealiser une simulation plus
complexe. Ces codes doivent r´eguli`erement ´echanger des donn´ees entre eux durant la « phase de
couplage » qui induit une synchronisation plus ou moins explicite. Il est donc n´ecessaire que les
diff´erents codes avancent `a la mˆeme vitesse pour ne pas se ralentir entre eux. Cet ´equilibrage entre
les codes peut s’av´erer tr`es difficile `a cause des natures tr`es diff´erentes de ces codes, ou dans le cas
o`u au moins un des codes a une charge de calcul qui ´evolue dynamiquement. La figure 1.2 pr´esente
un exemple avec deux codes coupl´es A et B utilisant initialement 3 processeurs chacun. Si
le code B devient trop rapide par rapport `a A, on peut transf´erer un processeur du code B vers A.
Cette th`ese propose un ensemble de m´ethodes permettant de r´esoudre le probl`eme d’´equilibrage
dynamique de la charge avec changement du nombre de processeurs, et ce en se basant sur3
le repartitionnement de graphe. Nous appellerons ce probl`eme, le repartitionnement M × N. Ce
repartitionnement doit r´ealiser les diff´erents objectifs d´ej`a cit´es :
— ´equilibrage de la charge ;
— minimisation des communications dues aux d´ependances de calculs ;
— rapidit´e de calcul de la nouvelle partition ;
— minimisation des communications dues `a la redistribution.
Ceci devra ˆetre fait en prenant en compte `a la fois une charge variable et un nombre de processeurs
variable.
Ces m´ethodes de repartitionnement se divisent en deux ´etapes : la construction d’une matrice
de migration puis le repartitionnement bas´e sur cette matrice de migration. Plusieurs m´ethodes
de construction de matrices de migration permettent d’optimiser diff´erentes m´etriques relatives
`a la migration des donn´ees. Deux m´ethodes de repartitionnement sont pr´esent´ees : l’une de
partitionnement biais´e et l’autre diffusive. De plus, des limitations des m´ethodes de bissections
r´ecursives utilis´ees habituellement sont mises en ´evidence dans le cadre du partitionnement biais´e
et nous proposons une m´ethode de partitionnement k-aire direct pour y rem´edier.
Nous commencerons par pr´esenter un ´etat de l’art du partitionnement et repartitionnement
de graphe (chapitre 2). Puis, dans le chapitre 3, nous d´efinirons et construirons des mod`eles
pour la migration. Le chapitre 4 pr´esentera des m´ethodes de repartitionnement s’appuyant sur
les mod`eles de migration introduits au chapitre pr´ec´edent. Puis, nous ´evaluerons nos m´ethodes
au travers d’une s´erie d’exp´eriences comparatives avec d’autres outils de repartitionnement de
graphe (chapitre 5). Finalement, nous conclurons et pr´esenterons quelques pistes d’am´eliorations
de ces m´ethodes dans le chapitre 6. Plusieurs annexes compl`etent ce manuscrit.4 CHAPITRE 1. INTRODUCTIONChapitre 2
Etat de l’art
´
Sommaire
2.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Partitionnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2.1 Mod´elisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2.2 M´ethodes de partitionnement de graphe . . . . . . . . . . . . . . . . . 9
2.2.3 Etat de l’art des outils de partitionnement . . . . . . . . . . . . . . . . ´ 11
2.3 Repartitionnement pour l’´equilibrage dynamique . . . . . . . . . . 13
2.3.1 Mod´elisation du probl`eme de repartitionnement . . . . . . . . . . . . . 13
2.3.2 M´ethodes de repartitionnement de graphe . . . . . . . . . . . . . . . . 14
2.4 Positionnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.1 Contexte
Une simulation num´erique mod´elise l’´evolution d’un ph´enom`ene physique dans le temps sur
un domaine de l’espace. Ces simulations s’appuient sur une discr´etisation en temps et en espace.
Le domaine de l’espace simul´e est discr´etis´e `a l’aide d’un maillage d’´el´ements g´eom´etriques :
triangles, carr´es, t´etra`edres, ... La discr´etisation en temps permet de calculer l’´etat du syst`eme
`a un instant donn´e `a partir de l’´etat pr´ec´edent. Plus pr´ecis´ement, l’´etat d’un ´el´ement est calcul´e
`a partir de son ´etat pr´ec´edent et de l’´etat de quelques autres ´el´ements en fonction du mod`ele
physique ; g´en´eralement, ce sont les ´el´ements voisins dans le maillage.
Ces simulations, de plus en plus complexes, n´ecessitent d’ˆetre ex´ecut´ees en parall`ele. Le domaine
doit donc ˆetre distribu´e parmi plusieurs unit´es de calcul. Le maillage est donc d´ecoup´e
en autant de parties que de processeurs utilis´es. Le calcul de l’´etat d’un ´el´ement d´ependant de
l’´etat d’autres ´el´ements, le plus souvent dans son voisinage, cette distribution induit des communications
entre processeurs quand l’un d’entre eux n´ecessite les donn´ees poss´ed´ees par un autre.
Ces communications sont synchronisantes et tous les processeurs doivent donc faire progresser la
simulation au mˆeme rythme. Une bonne distribution ou partition des donn´ees doit donc fournir
des parties ´equilibr´ees et minimisant le nombre de d´ependances de donn´ees entre processeurs,
minimisant ainsi le temps de calcul et de communication. Par exemple, un code simulant la diffusion
de la chaleur sur un maillage calcule la chaleur de chaque ´el´ement `a partir de sa propre
chaleur et de celle des ´el´ements voisins `a l’it´eration pr´ec´edente. Une unit´e de calcul travaillant
56 CHAPITRE 2. ETAT DE L’ART ´
sur un domaine doit donc recevoir les temp´eratures des ´el´ements sur la fronti`ere des domaines
voisins.
La distribution des donn´ees peut ˆetre statique, c’est-`a-dire fix´ee au d´ebut de la simulation,
ou dynamique qui ´evolue au cours de la simulation. Certaines simulations utilisent des maillages
dynamiques : le domaine de simulation peut s’´etendre, par exemple pour la simulation d’une
explosion, ou le maillage peut ˆetre raffin´e autour de certains points d’int´erˆet permettant ainsi
d’utiliser peu d’´el´ements tout en gardant une bonne pr´ecision l`a o`u c’est n´ecessaire. Cette derni`ere
m´ethode est appel´ee Adaptive Mesh Refinment (AMR). Au cours de ces simulations dynamiques,
la charge de calcul des processeurs ´evolue de fa¸con h´et´erog`ene. Il est donc n´ecessaire de r´e´equilibrer
r´eguli`erement cette charge en calculant une nouvelle partition des donn´ees. Une fois cette
nouvelle partition r´ealis´ee, les donn´ees doivent ˆetre migr´ees vers leur nouveau propri´etaire. La
nouvelle partition doit optimiser cette phase de migration en plus des crit`eres pr´ec´edents.
Il existe une grande vari´et´e de m´ethodes pour partitionner des maillages. Les plus courantes
sont les m´ethodes g´eom´etriques, s’appuyant uniquement sur les coordonn´ees des ´el´ements dans
l’espace, et les m´ethodes bas´ees sur les graphes utilisant les d´ependances de calcul entre ´el´ements
et ne s’int´eressant plus qu’`a la topologie et non `a la g´eom´etrie du probl`eme.
2.2 Partitionnement
Le partitionnement de maillages `a l’aide de graphes utilise les d´ependances de calcul entre les
´el´ements pour construire un graphe. Certains partitionneurs utilisent un mod`ele d’hypergraphe,
plus g´en´eral que le mod`ele de graphe. Un partitionneur de graphe ou d’hypergraphe calcule des
partitions en prenant en compte deux objectifs :
— les parties doivent ˆetre ´equilibr´ees, c’est-`a-dire de mˆeme taille. Les partitionneurs sont
g´en´eralement tol´erants et se contentent de cr´eer des parties `a peu pr`es ´equilibr´ees `a un
« facteur de d´es´equilibre » pr`es. Un facteur de d´es´equilibre de 5% veut dire qu’une partie
pourra atteindre jusqu’`a 1, 05 fois sa taille id´eale. Ce premier objectif permet d’optimiser
le temps de calcul de la simulation.
— une fonction de coˆut, appel´ee coupe du graphe, est minimis´ee. Cette fonction de coˆut varie
suivant les mod`eles mais repr´esente le temps de communication entre les processeurs.
2.2.1 Mod´elisation
Pour pouvoir appliquer le partitionnement de graphe ou d’hypergraphe `a un probl`eme donn´e,
il est n´ecessaire de mod´eliser celui-ci. Il est important de choisir une mod´elisation adapt´ee au
probl`eme pour que le partitionneur puisse cr´eer une partition optimisant les bons crit`eres pour
cette simulation.
a) Mod´elisation `a l’aide de graphes
L’approche la plus courante consiste `a mod´eliser les ´el´ements `a distribuer sous forme d’un
graphe. Le graphe construit doit mod´eliser les contraintes du calcul distribu´e : ´equilibrage de
charge et r´eduction de communications.
Un graphe est d´efini par un ensemble de sommets et un ensemble d’arˆetes connectant les
sommets par paires. Le graphe est donc construit avec un sommet pour repr´esenter chaque
´el´ement. Les arˆetes de ce graphe servent `a repr´esenter les d´ependances entre les ´el´ements. Par
exemple, le calcul sur un ´el´ement peut n´ecessiter les donn´ees des ´el´ements voisins dans le maillage.
Un sommet est donc connect´e `a tous les sommets repr´esentant les ´el´ements voisins dans le
maillage.2.2. PARTITIONNEMENT 7
Si des ´el´ements sont associ´es `a des charges de calcul diff´erentes, il est possible d’associer des
poids aux sommets repr´esentant ces charges de calcul. De la mˆeme fa¸con, si certaines communications
sont plus coˆuteuses que d’autres, un poids peut ˆetre affect´e aux arˆetes.
Un partitionneur de graphe optimise deux objectifs : l’´equilibrage et la coupe. La taille d’une
partie est le nombre de sommets dans cette partie ou, s’ils sont pond´er´es, la somme des poids de
ceux-ci. La fonction de coˆut la plus g´en´eralement utilis´ee dans les partitionneurs de graphe est
le nombre d’arˆetes coup´ees (ou la somme de leurs poids). Une arˆete est dite « coup´ee » lorsque
ses deux extr´emit´es sont affect´ees `a des parties diff´erentes. On vise ainsi `a r´eduire le volume de
donn´ees `a communiquer entre processeurs.
La figure 2.1 pr´esente la mod´elisation d’un maillage : une grille de 2 × 3 carr´es sous forme de
graphe. Chaque sommet du graphe correspond `a un carr´e de la grille et est reli´e aux sommets
correspondant `a ses voisins dans le maillage.
Figure 2.1 – Un maillage de 6 ´el´ements et le graphe associ´e mod´elisant les d´ependances.
Cette mod´elisation, bien que tr`es r´epandue, ne mod´elise pas toujours parfaitement le volume
de communication n´ecessaire pour la distribution induite. On pourrait penser que comme une
arˆete relie deux sommets, chaque arˆete coup´ee induit deux sommets devant communiquer. Mais
un sommet peut avoir plusieurs arˆetes coup´ees par la mˆeme partie et la coupe du graphe peut
sur´evaluer le volume de communication induit par cette partition. Sur la figure 2.2, un maillage
de 6 ´el´ements est partitionn´e en deux : une partie bleue et une partie verte. Il y a 4 ´el´ements qui
ont au moins un voisin dans l’autre partie, ce sont les ´el´ements qui ont besoin d’ˆetre communiqu´es
avec l’autre processeur. Mais 3 arˆetes sont coup´ees par la partition.
Figure 2.2 – Maillage et graphe partitionn´es en deux.8 CHAPITRE 2. ETAT DE L’ART ´
Figure 2.3 – Un maillage de 6 ´el´ements et l’hypergraphe associ´e mod´elisant les d´ependances.
Pour ne pas surcharger le dessin, seule l’hyper-arˆete correspondant `a l’´el´ement rouge est repr´esent´ee.
b) Mod´elisation `a l’aide d’hypergraphes
Il est ´egalement possible d’utiliser une mod´elisation `a partir d’hypergraphe. Le partitionnement
d’hypergraphe est depuis longtemps utilis´e pour le partitionnement de VLSI [33, 59], mais
il est ´egalement int´eressant dans le cas du partitionnement de matrices ou de maillages [63].
Les hypergraphes sont des extensions des graphes, o`u une arˆete appel´ee hyper-arˆete, ne
connecte plus deux sommets mais un nombre quelconque de sommets. Un graphe peut ˆetre
consid´er´e comme un hypergraphe particulier contenant uniquement des hyper-arˆetes de taille 2.
Ces hyper-arˆetes plus complexes rendent la repr´esentation graphique des hypergraphe plus
difficile. Il existe plusieurs fa¸cons de repr´esenter une hyper-arˆete ; par exemple, on peut dessiner
une courbe entourant les sommets inclus dans l’hyper-arˆete. Il est aussi possible de repr´esenter
une hyper-arˆete par un sommet sp´ecial reli´e aux sommets qu’elle connecte. Cette repr´esentation
est en fait celle d’un graphe biparti dont les parties sont l’ensemble des sommets et l’ensemble
des hyper-arˆetes.
Comme avec les graphes, chaque ´el´ement d’un maillage est repr´esent´e par un sommet de
l’hypergraphe. Mais les hyper-arˆetes permettent de mod´eliser diff´eremment les d´ependances. Une
hyper-arˆete est associ´ee `a chaque sommet, repr´esentant toutes les d´ependances de cet ´el´ement.
Une hyper-arˆete contient donc le sommet auquel elle est associ´ee, ainsi que tous les sommets qui
d´ependent de celui-ci.
La figure 2.3 montre une hyper-arˆete de l’hypergraphe mod´elisant la grille 2×3. Cette hyperarˆete
est associ´ee au sommet rouge et contient tous les sommets voisins.
Cette nouvelle mod´elisation des d´ependances permet d’utiliser des mod`eles de coupe diff´erents
repr´esentant mieux les communications induites par le partitionnement. La coupe connectivit´e−1,
aussi app´el´ee λ−1, permet de repr´esenter fid`element les communications [63]. Ce mod`ele de coupe
prend en compte le nombre de parties coupant une arˆete. Si une hyper-arˆete est coup´ee par λ
parties, son poids est compt´e λ−1 fois dans la coupe finale. En effet, une hyper-arˆete est associ´ee
`a un ´el´ement et λ parties poss`edent des ´el´ements appartenant `a cette hyper-arˆete. Ces ´el´ements
sont soit ceux qui ont une d´ependance sur l’´el´ement associ´e `a l’hyper-arˆete, soit l’´el´ement luimˆeme.
Parmi ces λ parties, une poss`ede l’´el´ement et les λ−1 autres devront recevoir les donn´ees
associ´ees `a cet ´el´ement.
La figure 2.4 montre la mˆeme partition que la figure 2.2 mais en utilisant un mod`ele d’hypergraphe.
Parmi les 6 hyper-arˆetes de cet hypergraphe, 4 sont coup´ees (en rouge). Ce sont les
hyper-arˆetes associ´ees aux sommets se trouvant sur la fronti`ere.
La mod´elisation `a l’aide d’hypergraphe permet de mod´eliser exactement la quantit´e de donn´ees
se trouvant sur la fronti`ere des domaines contrairement `a la mod´elisation `a l’aide de graphe.2.2. PARTITIONNEMENT 9
Figure 2.4 – Maillage et hypergraphe partitionn´e en deux. Les hyper-arˆetes en rouge sont coup´ees
par les deux parties.
c) Sommets fixes
Certains partitionneurs permettent d’utiliser des sommets fixes. Ces sommets sont initialement
fix´es dans une partie et le partitionneur ne remettra pas en cause cette affectation, mais
en tiendra compte dans l’´equilibrage et l’optimisation de la coupe. Les sommets fixes ont ´et´e
largement utilis´es dans le cadre du partitionnement de VLSI [7] mais ont ´egalement trouv´e une
utilisation dans le cadre du r´e´equilibrage dynamique [2, 9]. Le probl`eme de partitionnement `a
sommets fixes est une version plus contrainte du partitionnement de graphe ou hypergraphe
compl`etement libre. Bien que le probl`eme puisse paraitre plus simple, comme il y a moins de
sommets `a placer dans les diff´erentes parties, les heuristiques ´elabor´ees pour le partitionnement
libre peuvent avoir du mal `a prendre en compte ces nouvelles contraintes [3, 7].
2.2.2 M´ethodes de partitionnement de graphe
Le partitionnement d’un graphe ou d’un hypergraphe est un probl`eme NP-complet [20,
GRAPH PARTITIONING]. On utilise donc diverses heuristiques pour pouvoir calculer une partition
en un temps raisonnable. La plupart des m´ethodes utilis´ees s’appliquent aussi bien sur des
graphes que sur des hypergraphes.
La plupart des partitionneurs de graphe ou d’hypergraphe utilisent des m´ethodes appel´ees
« multi-niveaux » [4, 22, 36]. L’approche multi-niveaux permet d’acc´el´erer les m´ethodes de partitionnement
classiques tout en gardant une bonne qualit´e. Cette approche se d´ecompose en trois
´etapes, comme indiqu´e en figure 2.5.
G0
G1
Gk
...
P0
P1
Pk
... Contraction
Expansion
Partitionnement
Initial
Figure 2.5 – Phases d’un partitionnement multi-niveaux.10 CHAPITRE 2. ETAT DE L’ART ´
La phase de contraction : Dans un premier temps, la taille du graphe est r´eduite en fusionnant
des sommets. Cela est r´ep´et´e pendant plusieurs it´erations, jusqu’`a obtenir un
graphe suffisamment petit. Une suite de graphes de taille d´ecroissante a ainsi ´et´e cr´e´ee :
(G0, G1, . . . , Gk).
Le partitionnement initial : Une fois que le graphe a ´et´e suffisamment contract´e, on applique
une heuristique de partitionnement pour calculer la partition Pk du graphe Gk. N’importe
quelle strat´egie de partitionnement peut ˆetre appliqu´ee ici. Certaines seront d´etaill´ees par
la suite.
La phase d’expansion : La suite des diff´erents graphes construits pendant l’´etape de contraction
est alors « remont´ee ». La partition Pi+1 du graphe Gi+1 est prolong´ee sur le graphe
Gi puis cette nouvelle partition Pi est raffin´ee `a l’aide d’une heuristique am´eliorant localement
la coupe.
a) Strat´egies de contraction
Il existe plusieurs heuristiques pour s´electionner les sommets `a fusionner. La plus connue,
appel´ee Heavy Edge Matching (HEM), recherche les arˆetes de poids les plus ´elev´es et en fusionne
les deux extr´emit´es. Cette op´eration est r´ep´et´ee jusqu’`a obtenir un graphe suffisamment petit.
Dans un partitionneur supportant les sommets fixes, ces derniers doivent ˆetre trait´es de mani`ere
particuli`ere pendant la phase de contraction. En effet, le graphe contract´e doit garder les mˆemes
informations sur les sommets fixes. Dans certains partitionneurs, il peut ˆetre d´ecid´e de ne jamais
fusionner ces sommets fixes. Dans d’autres, il peut ˆetre d´ecid´e de les fusionner seulement avec
des sommets non fix´es ou fix´es dans la mˆeme partie. Dans ce cas, le sommet obtenu apr`es fusion
est consid´er´e comme un sommet fixe dans le graphe contract´e.
b) Strat´egies de partitionnement initial
La strat´egie de partitionnement utilis´ee au niveau le plus bas dans un partitionneur multiniveaux
peut ˆetre n’importe quelle strat´egie de partitionnement, y compris un autre algorithme
multi-niveaux. Il existe une tr`es grande vari´et´e de m´ethodes de partitionnement ou de bissection
comme par exemple des algorithmes gloutons ajoutant les sommets un `a un dans les parties [5,
6, 29], ou des algorithmes spectraux utilisant des propri´et´es d’alg`ebre lin´eaire pour obtenir une
partition [53].
La strat´egie la plus utilis´ee est celle des bissections r´ecursives. Le graphe est coup´e r´ecursivement
en deux parties jusqu’`a obtenir le nombre de parties souhait´e. Il est possible d’obtenir
un nombre de parties qui n’est pas une puissance de 2 en cr´eant des parties d´es´equilibr´ees. Par
exemple pour obtenir 3 parties, on cr´ee deux parties avec les proportions 1/3 et 2/3, la partie
de taille 2/3 est ensuite coup´ee en deux parties ´egales de 1/3 chacune. Son int´erˆet r´eside
dans la grande vari´et´e et qualit´e des heuristiques de bissection souvent mieux maˆıtris´ees que les
heuristiques de partitionnement k-aires [35].
Le graphe peut ´egalement ˆetre partitionn´e directement en k parties ; on parlera de partitionnement
k-aire direct. Ces strat´egies peuvent ˆetre plus rapides que les bissections r´ecursives
car une seule partition est calcul´ee. Th´eoriquement, le partitionnement k-aire direct permet une
meilleure qualit´e car il profite d’une vision globale du probl`eme que les bissections r´ecursives n’ont
pas [60]. Mais en pratique, il est plus difficile de calculer une bonne partition k-aire directement
et la m´ethode des bissections r´ecursives donne souvent de meilleurs r´esultats [35].2.2. PARTITIONNEMENT 11
c) Strat´egies de raffinement utilis´ees dans la phase d’expansion
Les strat´egies de raffinement modifient une partition d´ej`a existante en changeant quelques
sommets de partie pour am´eliorer la coupe.
L’algorithme de Kernighan et Lin [39] (KL) raffine une bissection en cherchant des paires de
sommets dont l’´echange am´eliore le plus la coupe (ou la d´egrade le moins). Un sommet d´eplac´e ne
sera plus consid´er´e pour un ´echange dans la mˆeme passe. Ces ´echanges sont consid´er´es mˆeme s’ils
d´egradent la coupe, cela permettant de ne pas rester bloqu´e sur une solution localement optimale
mais qui pourrait ˆetre am´elior´ee en s’en ´eloignant plus. A la fin de la passe, seuls les ´echanges `
menant `a la meilleure coupe sont conserv´es. L’´echange par paires permet de conserver l’´equilibre
mais rend l’algorithme complexe. Plusieurs passes peuvent ˆetre appliqu´ees pour am´eliorer encore
plus la coupe.
Fiduccia et Mattheyses [17] (FM) s’inspirent de cet algorithme pour d´ecrire un raffinement
lin´eaire en temps en ne d´epla¸cant les sommets que un par un et grˆace `a une structure de donn´ees
adapt´ee. L’´equilibre est conserv´e en se refusant d’effectuer des d´eplacements qui d´es´equilibreraient
trop la partition, c’est-`a-dire que la partition d´epasserait la taille maximale donn´ee par le facteur
de d´es´equilibre. Cet algorithme, initialement con¸cu pour les bissections, a ´egalement l’avantage
de s’´etendre facilement aux k-partitions. Le principe g´en´eral reste le mˆeme, mais il y a plusieurs
d´eplacements `a consid´erer pour chaque sommet.
Les sommets fixes s’int`egrent facilement aux m´ethodes de types KL/FM, car il suffit de ne
pas consid´erer ces sommets parmi les d´eplacements possibles.
Comme un algorithme de raffinement se contente d’am´eliorer une partition d´ej`a existante en
ne d´epla¸cant souvent que les sommets le long de la fronti`ere, il n’est pas toujours n´ecessaire de
l’appliquer sur le graphe entier. Ces strat´egies sont souvent appliqu´ees sur un graphe « bande »
ne contenant que les sommets `a une certaine distance de la fronti`ere entre les parties, les autres
sommets ´etant r´eunis en un seul sommet fixe pour chaque partie appel´e « ancre ». La taille du
probl`eme est ainsi largement r´eduite [10].
D’autres m´ethodes de raffinement s’inspirent de la diffusion d’un liquide dans le graphe [42,49].
Ces m´ethodes se basent sur des graphes bandes : un type liquide diff´erent pour chaque partie
est inject´e dans chaque sommet ancre. Le liquide se diffuse it´erativement dans le graphe le long
des arˆetes et est d´etruit lorsqu’il rencontre un autre type de liquide. Quand un sommet re¸coit
plusieurs type de liquide, il choisit la partie dont il en re¸coit le plus. Cette heuristique tend
`a cr´eer des parties aux formes tr`es lisses mais la coupe n’est pas toujours optimale. Elle aussi
pour avantage d’ˆetre locale et donc d’ˆetre plus efficace en parall`ele que les heuristiques de type
KL/FM.
2.2.3 Etat de l’art des outils de partitionnement ´
Il existe une grande vari´et´e d’outils de partitionnement. Le tableau 2.1 pr´esente quelques partitionneurs
de graphe ou d’hypergraphe et quelques unes de leurs fonctionnalit´es. Les sommets
fixes sont surtout support´es par les partitionneurs d’hypergraphe car ils sont utilis´es depuis longtemps
pour le partitionnement de circuits int´egr´es (VLSI). Beaucoup de partitionneurs offrent le
choix entre un partitionnement multi-niveaux r´ecursif ou directement k-aire, mais le partitionnement
initial du multi-niveaux direct utilise le plus souvent des bissections r´ecursives.
Metis [31] est un des partitionneurs les plus connus et utilis´es. Il poss`ede deux m´ethode de
partitionnement : r´ecursif ou k-aire mais la m´ethode k-aire se base sur des bissections r´ecursives
pour son partitionnement initial. Il existe ´egalement une version parall`ele : ParMetis permettant
de cr´eer une partition en parall`ele sur au moins 2 processus. ParMetis propose ´egalement une
m´ethode de repartitionnement permettant de r´e´equilibrer une partition existante [57]. hMetis est
un partitionneur d’hypergraphe ´egalement disponible en version r´ecursive ou k-aire. Il supporte12 CHAPITRE 2.
´ETAT DE L’ART
Outil Type Sommets fixes Parall`ele Type de multi-niveaux Partitionnement initial
Metis [31] graphe non non bissections [34] —
k-aire [35] bissections
ParMetis [32] graphe non oui
k-aire [37] bissections
hMetis [30] hypergraphe oui non bissections [33] —
non
k-aire [38] bissections
PaToH [64] hypergraphe oui non bissections —
kPaToH [3] hypergraphe oui non
k-aire bissections + matching
Zoltan [1] hypergraphe oui oui bissections —
Scotch [48] graphe oui non bissections —
k-aire bissections
PT-Scotch [48] graphe non oui bissections
RM-Metis [2] graphe oui (exactement
k) non
k-aire
k-aire direct (GGGP)
Mondriaan [62] hypergraphe non non bissections —
ML-Part [47] hypergraphe oui non bissections —
Parkway [61] hypergraphe non oui
k-aire bissections
Chaco [24] graphe non non bissections —
Table 2.1 – Partitionneurs de graphe et d’hypergraphe.2.3. REPARTITIONNEMENT POUR L’EQUILIBRAGE DYNAMIQUE ´ 13
les sommets fixes mais ne peut optimiser que le nombre d’hyper-arˆetes coup´ees et non la coupe
λ − 1.
Scotch [48] est un partitionneur de graphe et de maillage sous licence libre. Il est tr`es configurable
et modulaire. Il propose une grande vari´et´e de m´ethodes de partitionnement, mais seulement
des m´ethodes de bissections sont disponibles pour le partitionnement initial. Depuis sa derni`ere
version (6.0), il permet d’utiliser des sommets fixes et de r´e´equilibrer une partition existante.
PT-Scotch est la version parall`ele multi-thread et multi-processus de Scotch.
Zoltan [1] est une biblioth`eque permettant de g´erer la distribution des donn´ees pour des
applications parall`eles. Il offre en particulier des fonctionnalit´es de partitionneur. Il est possible
d’utiliser ParMetis ou Scotch, mais il contient ´egalement son propre partitionneur d’hypergraphe.
Le partitionneur d’hypergraphe de Zoltan utilise des bissections r´ecursives et supporte les sommets
fixes. Il est ´egalement capable de r´e´equilibrer la distribution des donn´ees lorsque celles-ci
´evoluent dynamiquement [8, 9].
2.3 Repartitionnement pour l’´equilibrage dynamique
Dans certaines simulations num´eriques, la charge varie dynamiquement. C’est par exemple le
cas des simulations AMR (Adaptive Mesh Refinement) dans lesquelles la r´esolution du maillage
s’adapte dynamiquement pour r´eduire la quantit´e de calcul tout en gardant une pr´ecision suffi-
sante l`a o`u elle est n´ecessaire.
La charge ne varie pas de fa¸con homog`ene et il devient n´ecessaire apr`es un certain temps de
simulation de r´e´equilibrer la charge entre les diff´erents processeurs. Le graphe repr´esentant les
donn´ees doit alors ˆetre « repartitionn´e ». Les objectifs du repartitionnement de graphe sont :
— la charge de calcul doit ˆetre ´equilibr´ee entre tous les processeurs ;
— le volume de donn´ees `a communiquer entre les processeurs doit ˆetre minimal ;
— le temps de calcul de la nouvelle partition doit ˆetre minimal ;
— la migration des donn´ees, c’est `a dire l’envoi depuis l’ancien propri´etaire des sommets vers
le nouveau, doit ˆetre le plus rapide possible.
Aux deux premiers objectifs communs avec le partitionnement classique, on ajoute la minimisation
du temps de repartitionnement (calcul de la nouvelle partition et migration induite par
celle-ci). Notons que pour obtenir une partition de qualit´e (d’apr`es les deux premiers crit`eres), il
est souvent n´ecessaire de migrer beaucoup de sommets.
2.3.1 Mod´elisation du probl`eme de repartitionnement
On peut exprimer le temps total de la simulation (Ttotal) `a minimiser sous la forme [8, 57] :
Ttotal = α × (Tcalcul + Tcomm) + Trepart + Tmig
avec :
— α le nombre d’it´erations avant que la partition devienne trop d´es´equilibr´ee et qu’un repartitionnement
devienne n´ecessaire ;
— Tcalcul le temps d’une it´eration de calcul, pris sur le processeur le plus lent et donc minimis´e
par l’´equilibrage ;
— Tcomm le temps des communications entre processeurs, correspondant `a la coupe du
graphe ;
— Trepart le temps pass´e `a calculer la nouvelle partition ;
— Tmig le temps de migration des sommets vers leur nouvelle partie.14 CHAPITRE 2. ETAT DE L’ART ´
Ce mod`ele d’une simulation it´erative est repr´esent´e en figure 2.6. Apr`es chaque it´eration de calcul,
les processeurs effectuent une phase de communication collective qui les synchronise ; le temps de
calcul en parall`ele est donc celui du processeur le plus lent. Apr`es α = 3 it´erations, la partition
devient trop d´es´equilibr´ee ; une nouvelle partition est calcul´ee lors du repartitionnement puis les
sommets sont migr´es pour respecter cette nouvelle partition.
En pratique, le repartitionnement n’est pas effectu´e apr`es un nombre fixe d’it´erations mais
quand le d´es´equilibre d´epasse un certain seuil. On peut alors consid´erer que α est le nombre
moyen d’it´erations avant que ce seuil soit d´epass´e.
Obtenir une nouvelle partition de qualit´e (c’est-`a-dire avec Tcalcul et Tcomm faibles), impose
un repartitionnement plus complexe et une nouvelle partition plus ´eloign´ee de l’ancienne (Trepart
et Tmig plus ´elev´es). Il est donc n´ecessaire de r´ealiser un compromis suivant la valeur de α entre
la qualit´e de la nouvelle partition et la rapidit´e de sa construction et mise en place. Si le besoin
de repartitionnement est rare (α ´elev´e), il faut privil´egier la qualit´e de la partition avant celle de
la migration. Mais pour les applications tr`es dynamiques qui n´ecessitent des repartitionnements
fr´equents (α faible), il faut mieux privil´egier la migration devant la qualit´e de la partition qui se
d´egradera de toute fa¸con rapidement.
Concernant la migration, diff´erents crit`eres peuvent ˆetre optimis´es [44]. L’objectif le plus
souvent optimis´e est le volume total des donn´ees migr´ees, appel´e volume total de migration. Mais
il peut aussi ˆetre int´eressant de minimiser le volume de migration par processeur, ou encore le
nombre de messages n´ecessaires `a la migration d’un point de vue global ou par processeur.
Les communications de migration peuvent ˆetre mod´elis´ees par une matrice que nous appellerons
matrice de migration dans laquelle chaque ´el´ement repr´esente le volume de donn´ees d’un
message. Chaque ligne est associ´ee `a un processeur (et `a son ancienne partie) et chaque colonne
est associ´ee `a une nouvelle partie. L’´el´ement (i, j) repr´esente le volume de donn´ees que le
processeur i enverra au processeur associ´e `a la nouvelle partie j.
La figure 2.7 pr´esente deux exemples de repartitionnement. La partition initiale sur la fi-
gure 2.7a est d´es´equilibr´ee : la partie 1 poss`ede quatre sommets alors que la partie 3 n’en a que
deux. Les figures 2.7b et 2.7c pr´esentent deux nouvelles partitions et les matrices de migrations
associ´ees. Les sommets migrants (en rouge) correspondent aux ´el´ements hors diagonale alors que
les sommets ne migrant pas correspondent aux ´el´ements de la diagonale (les messages qu’une
partie « s’envoie » `a elle-mˆeme). Par exemple, sur la figure 2.7c, la nouvelle partie 4 contient
deux sommets de l’ancienne partie 4 et un de l’ancienne partie 1 : la quatri`eme colonne de la
matrice contient donc un 1 sur la premi`ere ligne et un 2 sur la quatri`eme.
2.3.2 M´ethodes de repartitionnement de graphe
Pour ´equilibrer la charge, il existe diff´erentes approches bas´ees sur le repartitionnement de
graphe dont les plus courantes sont le Scratch-Remap, les m´ethodes diffusives et le partitionnement
biais´e. Il existe d’autres approches bas´ees des m´ethodes g´eom´etriques (bissections r´ecursives
ou SFC [52]) ou encore des m´ethodes spectrales modifi´ees pour prendre en compte la
migration [23]. Nous allors maintenant pr´esenter les trois approches les plus courantes.
a) Scratch-Remap
La m´ethode la plus simple et la plus ´evidente est le « Scratch-Remap ». Cette m´ethode
se d´ecompose en deux ´etapes. Dans un premier un temps, le graphe est partitionn´e « from
scratch », c’est-`a-dire sans prendre en compte l’ancienne partition. Ensuite les parties obtenues
sont renum´erot´ees pour optimiser la migration.2.3. REPARTITIONNEMENT POUR L’EQUILIBRAGE DYNAMIQUE ´ 15 Calcul Calcul Calcul Calcul Calcul Calcul Calcul Calcul
Communications
Calcul
Calcul
Calcul
Calcul
Calcul
Calcul
Calcul
Calcul
Communications
Calcul
Calcul
Calcul
Calcul
Calcul
Calcul
Calcul
Calcul
Communications
Repartitionnement
Migration
Calcul
Calcul
Calcul
Calcul
Calcul
Calcul
Calcul
Calcul
Communications
Calcul
Calcul
Calcul
Calcul
Calcul
Calcul
Calcul
Calcul
Communications
Calcul
Calcul
Calcul
Calcul
Calcul
Calcul
Calcul
Calcul
Communications
Repartitionnement
Migration
Figure 2.6 – Etapes d’un code se r´e´equilibrant toutes les
´ α = 3 it´erations.16 CHAPITRE 2. ETAT DE L’ART ´
1
2
3
4
(a) Partition initiale d´es´equilibr´ee
en 4 parties.
4 3
1 2
1 0 0 3
0 0 3 0
0 2 0 0
2 1 0 0
(b) Partition en 4 parties avec
une mauvaise correspondance
des parties.
1 2
4 3
3 0 0 1
0 3 0 0
0 0 2 0
0 0 1 2
(c) Mˆeme partition que pr´ec´edemment
mais avec une bonne
correspondance.
Figure 2.7 – Exemples de repartitionnement. Les sommets migrants sont dessin´es en rouge.
La figure 2.7 pr´esente deux exemples de repartitionnement produisant la mˆeme nouvelle
partition, mais avec une num´erotation diff´erente des nouvelles parties. Un repartitionnement
« from scratch » peut tout `a fait donner la partition de la figure 2.7b o`u tous les sommets sauf
un sont migr´es, alors qu’en renum´erotant les nouvelles parties par rapport `a l’ancienne partition
comme sur la figure 2.7c, seulement deux sommets doivent ˆetre migr´es.
Dans PLUM, Oliker et Biswas [45] proposent une heuristique gloutonne pour r´esoudre le probl`eme
d’association des nouvelles parties aux processeurs (remap). Cette heuristique est d´ecrite
par l’algorithme 1. Il parcourt les ´el´ements Ci,j de la matrice de migration du plus grand au
plus petit ´el´ement. La partie j est associ´ee au processeur i d`es que c’est possible, c’est-`a-dire si
le processeur i est libre (free[i] est vrai) et si la partie j n’est pas d´ej`a associ´ee `a un processeur
(unassigned[j] est vrai). L’algorithme se termine lorsque toutes les parties ont ´et´e affect´ees `a un
processeur.
Comme la m´ethode Scratch-Remap recalcule une partition sans prendre en compte la migration,
celle-ci poss`ede g´en´eralement une bonne coupe car c’est le seul crit`ere optimis´e lors du
partitionnement. En revanche, la migration n’est minimis´ee que dans un second temps et peut
ˆetre tr`es sup´erieure `a l’optimal.
Il est possible d’apporter quelques am´eliorations au Scratch-Remap. Pour obtenir un volume
de migration plus faible, Oliker et Biswas [45] repartitionne en kM parties au lieu de M. Lors
de la phase de remapping, k nouvelles parties sont associ´ees `a chaque processeur. Ce grain plus
fin permet un volume de migration moindre mais une coupe un peu plus ´elev´ee. Schloegel et
al. [58] proposent une autre variante du Scratch-Remap appel´ee LMSR (Locally Matched Scratch
Remap) dans laquelle la phase de contraction du partitionnement multi-niveaux est contrainte
pour ne fusionner que des sommets appartenant `a une mˆeme ancienne partie en esp´erant cr´eer
une nouvelle partition avec des fronti`eres plus proches de l’ancienne partition.
b) Diffusion
Les m´ethodes diffusives s’inspirent du ph´enom`ene physique de diffusion de la chaleur pour
r´e´equilibrer la charge. L’id´ee de base des m´ethodes diffusives est que chaque processeur ´echange2.3. REPARTITIONNEMENT POUR L’EQUILIBRAGE DYNAMIQUE ´ 17
Algorithme 1 R´eaffectation des nouvelles parties aux anciens processeurs (remap)
Entr´ee : Matrice de migration C de taille M × M
map : vecteur d’association des nouvelles parties
unassigned : vecteur de bool´eens initialement vrais
free : vecteur de bool´eens initialement vrais
n ← M
L ← liste tri´ee des Ci,j par ordre d´ecroissant
tant que n > 0 faire
Prendre et retirer le premier ´el´ement Ci,j de L
si free[i] ∧ unassigned[j] alors
map[j] ← i
free[i] ← faux
unassigned[j] ← faux
n ← n − 1
fin si
fin tant que
retourner map
des sommets avec ses voisins selon le d´es´equilibre de charge entre les deux parties. Ces ´echanges
locaux de sommets `a la fronti`ere des parties concern´ees permettent de r´e´equilibrer la charge.
Dans la version it´erative de cette m´ethode, un r´e´equilibrage partiel est r´ep´et´e `a chaque it´eration.
Lors de ce r´e´equilibrage partiel, deux processeurs voisins ´echangent un nombre de sommets
proportionnel `a leur diff´erence de charge. Cybenko [12] calcule la nouvelle charge w
(t+1)
i
d’une
partie i `a l’it´eration t + 1, `a l’aide la formule :
w
(t+1)
i = w
(t)
i +
X
j
αij (w
(t)
j − w
(t)
i
). (2.1)
Les αij sont des coefficients positifs ou nuls et tels que ∀i,P
j αij ≤ 1 (chaque partie ne peut pas
donner plus de charge qu’elle n’en poss`ede), permettant de choisir si les parties i et j ´echangeront
facilement des sommets. Cela permet de favoriser les ´echanges entre parties proches dans le
graphe ou entre processeurs proches sur le r´eseau. Apr`es plusieurs it´erations, cette m´ethode tend
`a homog´en´eiser la charge, conform´ement au principe de diffusion de la chaleur.
Le r´e´equilibrage peut ´egalement ˆetre r´ealis´e directement en cherchant la solution finale du
probl`eme de diffusion `a l’aide d’un solveur. Hu et Blake [26] montrent que chercher la solution
optimisant la norme 2 de la migration (la racine carr´e de la somme des carr´es de la taille de
chaque message) est ´equivalent au probl`eme de diffusion. La solution est calcul´ee `a l’aide de la
m´ethode du gradient conjugu´e.
Ou et Ranka [46] expriment le probl`eme sous forme d’un programme lin´eaire pour minimiser
la norme 1 de la migration (la somme des tailles de chaque message). Ce programme est r´esolu
`a l’aide de la m´ethode du simplexe [43].
Une fois que la charge `a ´echanger entre chaque processeur a ´et´e d´ecid´ee, il faut choisir quels
seront les sommets `a migrer. Ce choix est fait de fa¸con `a optimiser la coupe de la partition finale
et peut ˆetre r´ealis´e `a l’aide d’un algorithme de type FM. Comme les d´eplacements de sommets
s’effectuent entre des pairs de parties, il est n´ecessaire de trouver un bon ordonnancement de
ses migrations [58]. En effet un processeur peut avoir besoin de transmettre plus de sommets
qu’il n’en poss`ede initialement et il a donc besoin de recevoir des sommets avant de pouvoir en
envoyer.18 CHAPITRE 2. ETAT DE L’ART ´
1
2
3
(a) Partition d´es´equilibr´ee.
0
0
1
1
2
3
(b) Echanges de sommets entre ´
parties.
1
2
3
(c) Partition finale r´e´equilibr´ee.
Figure 2.8 – Exemple de diffusion.
Un exemple de repartitionnement par diffusion est illustr´e sur la figure 2.8. Tous les sommets
sont de poids unitaires. A partir de la partition initialement d´es´equilibr´ee (figure 2.8a) ` , on calcule
la migration optimale (figure 2.8b). Il faut alors d´eplacer un sommet de la partie 3 vers la partie
2. Ce sommet est choisi de fa¸con `a obtenir la meilleure coupe possible et ainsi obtenir la partition
finale ´equilibr´ee de la figure 2.8c.
Les m´ethodes diffusives permettent d’obtenir de faibles volumes de migration. Mais les heuristiques
locales utilis´ees se comportent mal si il y a de grandes variations de charge.
c) Partitionnement biais´e
Le partitionnement peut ˆetre biais´e pour optimiser la migration. Les heuristiques habituelles
sont modifi´ees pour ne plus optimiser seulement la coupe mais un compromis entre la coupe et
le volume total de migration.
Au lieu de modifier les heuristiques, il est ´egalement possible de modifier le graphe `a partitionner
pour biaiser le partitionnement. Plusieurs ´etudes [2, 8, 9] montrent qu’il est possible de
mod´eliser le probl`eme de repartitionnement `a l’aide de sommets fixes. Le graphe `a partitionner
est enrichi pour mod´eliser les objectifs du repartitionnement : la coupe des arˆetes ajout´ees repr´esente
la migration des sommets. Cette m´ethode est utilis´ee par le partitionneur d’hypergraphe
Zoltan [9] et le partitionneur de graphe RM-Metis [2].
Des sommets sont ajout´es dans ce graphe pour mod´eliser les processeurs. Les processeurs ne
sont pas des calculs `a distribuer ; le poids de ces sommets est donc nul et ils sont fix´es dans
la partie du processeur qu’il mod´elise, c’est-`a-dire que le partitionneur ne pourra pas les placer
dans une autre partie. Ces sommets fixes sont ensuite connect´es `a tous les sommets contenus
dans l’ancienne partie associ´ee au sommet fixe. Ces nouvelles arˆetes permettent de mod´eliser la
migration et sont donc appel´ees arˆetes de migration. En effet, si un sommet est migr´e, l’arˆete
le connectant au sommet fixe de son ancienne partie sera coup´ee, ajoutant ainsi un coˆut de
migration dans la taille de la coupe de la nouvelle partition. Le poids de l’arˆete de migration
permet donc de repr´esenter la taille des donn´ees `a migrer.
Sur la figure 2.9, on peut voir un exemple de repartitionnement qui illustre cette m´ethode. La
partition en 5 parties est initialement d´es´equilibr´ee ; 5 sommets fixes (carr´es) sont ajout´es et reli´es
par des arˆetes de migration aux sommets de leur partie respective (figure 2.9a). Apr`es l’utilisation
d’un partitionneur `a sommets fixes, une nouvelle partition ´equilibr´ee est obtenue (figure 2.9b).
Les arˆetes de migration associ´ees aux sommets ayant migr´e sont coup´ees (en rouge). La plus2.3. REPARTITIONNEMENT POUR L’EQUILIBRAGE DYNAMIQUE ´ 19
(a) Graphe colori´e selon l’ancienne partition auquel les sommets fixes ont
´et´e ajout´es.
(b) Graphe colori´e selon la nouvelle partition. Les arˆetes de migration
coup´ees sont colori´ees en rouge.
Figure 2.9 – Exemple de repartitionnement bas´e sur des sommets fixes.20 CHAPITRE 2. ETAT DE L’ART ´
grande partie des arˆetes n’est pas coup´ee (en vert). Le partitionneur a donc cr´e´e une nouvelle
partition avec peu de migration (15 sommets migrent correspondant aux 15 arˆetes de migration
coup´ees).
Scotch [18,19] utilise une m´ethode de repartitionnement biais´e : sa m´ethode de raffinement par
« diffusion » est modifi´ee dans le cas du repartitionnement. Pour prendre en compte la migration
des sommets, une nouvelle source de « liquide » est ajout´ee pour chaque sommet l’incitant `a
rester dans sa partie d’origine.
Hendrikson et al. [23] proposent une autre approche du repartitionnement biais´e o`u chaque
sommet u a un d´esir dk(u) d’ˆetre dans un partie k. Au lieu de minimiser le coˆut de migration,
le but est de maximiser les d´esirs de chaque sommet (si p(u) est la partie de u, on maximise la
somme P
u
dp(u)(u)). Deux approches sont pr´esent´ees : un raffinement de type FM modifi´e et
une m´ethode de partitionnement spectrale prenant en compte les d´esirs des sommets.
Le partitionnement biais´e permet un compromis entre qualit´e de la nouvelle partition et volume
de migration grˆace `a un coˆut de migration introduit dans la coupe `a optimiser, par exemple,
`a l’aide du poids des arˆetes de migration. Mais le repartitionnement est plus complexe car une
nouvelle partition est compl`etement recalcul´ee avec des heuristiques modifi´ees.
Le partitionnement biais´e peut ´egalement ˆetre hybride [57]. Dans le cadre d’un partitionnement
multi-niveaux, le partitionnement initial est r´ealis´e `a l’aide d’une m´ethode Scratch-Remap
ou diffusive, mais le raffinement appliqu´e lors de la phase d’expansion est biais´e pour optimiser
la migration.
2.4 Positionnement
Toutes les m´ethodes de repartitionnement pour l’´equilibrage dynamique pr´esent´ees ici ne
s’int´eressent qu’au cas o`u le nombre de processeurs reste fixe. Le probl`eme de l’´equilibrage dynamique
avec variation du nombre de processeurs est peu ´etudi´e. Iqbal et Carey [27,28] ont pourtant
montr´e que faire varier le nombre de processeurs au cours de la simulation permet d’optimiser la
consommation de ressources et mˆeme, dans certains cas, le temps d’ex´ecution.
Bien choisir le nombre de processeurs allou´es `a une simulation est essentiel pour avoir une
bonne performance ou efficacit´e. Si une simulation est lanc´ee en parall`ele sur un trop grand
nombre de processeurs, le temps pass´e `a communiquer peut devenir trop important par rapport
au temps de calcul. Utiliser le maximum de processeurs possible n’est pas toujours un bon choix
suivant la taille du probl`eme. La taille du probl`eme pouvant varier au cours de la simulation, le
nombre de processeurs devrait varier en cons´equence.
Augmentation
de la charge
M = 4 N = 6
Figure 2.10 – Allocation dynamique de processeurs pour un seul code dont la charge augmente.
Par exemple, un code AMR (Adaptive Mesh Refinement) commence sa simulation sur un
maillage grossier contenant peu d’´el´ements. Puis, au cours de la simulation, le maillage est raf-2.4. POSITIONNEMENT 21
Augmentation de la
charge relative A/B
M + M' = 6 N + N' = 6
A B A B
Figure 2.11 – Allocation dynamique de processeurs pour deux codes coupl´es A et B dont la
charge relative de A par rapport `a B augmente.
fin´e l`a o`u c’est n´ecessaire. La charge de calcul, initialement tr`es faible, croˆıt avec le temps. La
simulation tr`es l´eg`ere au d´ebut finit par demander beaucoup de ressources, que ce soit en puissance
de calcul ou en m´emoire. En commen¸cant le calcul sur tr`es peu de processeurs puis en
l’augmentant quand la limite m´emoire est atteinte, il est possible de garder une meilleure efficacit´e
tout le long de la simulation. Les surcoˆuts dus au parall´elisme inutile en d´ebut de simulation
sont ´evit´es quand c’est possible. C’est la cas pr´esent´e sur la figure 2.10 : apr`es une augmentation
significative de la charge, deux processeurs suppl´ementaires sont allou´es, et il faut donc effectuer
un repartitionnement de 4 processeurs vers 6.
L’allocation dynamique de processeurs peut aussi ˆetre utile dans le cas du couplage de codes.
Dans un couplage de codes, plusieurs codes parall`eles s’ex´ecutent simultan´ement et doivent r´eguli`erement
´echanger des donn´ees. Cette phase d’´echange est synchronisante. Il est donc important
que tous les codes concern´es progressent `a la mˆeme vitesse pour minimiser le temps d’attente
lors de cette synchronisation. Le choix du nombre de processeurs utilis´es par chaque code doit
ˆetre fait en prenant en compte les charges relatives de chacun. Cette ´equilibrage entre plusieurs
codes peut ˆetre difficile, plus particuli`erement si la charge de ces codes peut varier dynamiquement.
Pour r´e´equilibrer ces codes, une solution serait donc de r´eallouer des ressources d’un code
vers un autre. Le nombre id´eal de processeurs allou´es `a chaque code peut donc ˆetre approch´e
exp´erimentalement en corrigeant au cours de la simulation les d´es´equilibre qui surviendraient.
Par exemple, sur la figure 2.11, le code A est devenu trop lent par rapport `a B, un processeur
est donc r´eallou´e du code B vers le code A. Il faut repartitionner chacun des deux codes : de 3
processeurs vers 4 pour A, et de 3 vers 2 pour B.
Pour r´ealiser ce changement du nombre de ressources, il est n´ecessaire de mettre en place
une m´ethode repartitionnement prenant en compte le changement du nombre de parties. Nous
appelons ce probl`eme, le repartitionnement M × N. Les objectifs du repartitionnement sont
similaires `a ceux du repartitionnement classiques :
— ´equilibrer la charge parmi les N processeurs ;
— minimiser la coupe du graphe ;
— calculer rapidement la nouvelle partition ;
— minimiser la migration (diff´erentes m´etriques seront pr´esent´ees).
Les outils de repartitionnement suivent d´ej`a ces objectifs mais ne sont pas pr´evus pour le changement
du nombre de processeurs. La m´ethode de Scratch-Remap est facilement adaptable au
repartitionnement M × N. Lors du partitionnement from scratch, l’ancienne partition, et donc
l’ancien nombre de processeurs, n’a pas d’influence. L’algorithme de Remapping peut ˆetre facilement
adapt´e en prenant en compte le fait que certaines parties ne seront pas associ´ees `a un
ancien processeur (lors de l’ajout de processeurs), ou que des anciens processeurs ne recevront
pas de nouvelles parties (lors de la suppression de processeurs).22 CHAPITRE 2. ETAT DE L’ART ´
Nous proposons donc une nouvelle m´ethode de repartitionnement adapt´ee au cas o`u le nombre
de processeurs varie. La m´ethode propos´ee est pr´esent´ee sur la figure 2.12. Elle se d´ecompose en
deux ´etapes.
Dans un premier temps, nous cherchons `a construire des matrices de migrations adapt´ees `a ce
probl`eme. Apr`es une ´etude de quelques matrices optimales, plusieurs m´ethodes seront pr´esent´ees
dans le chapitre 3. La construction de la matrice de migration ne s’int´eresse pas aux sommets du
graphe individuellement mais seulement aux parties, `a leurs tailles et `a leurs positions respectives.
Ainsi, la construction de la matrice s’effectue `a partir du graphe quotient des parties.
Ensuite, la matrice de migration construite est utilis´ee pour guider un repartitionnement du
graphe remplissant les objectifs habituels du partitionnement de graphe : l’´equilibre et la coupe
tout en fournissant une migration telle que pr´evue par la matrice construite `a l’´etape pr´ec´edente.
Plusieurs approches sont possibles : un partitionnement biais´e utilisant des sommets fixes pour
imposer une matrice de migration lors du repartitionnement ; une approche diffusive adapt´ee
pour le repartitionnement M × N ; et un partitionnement biais´e utilisant des hyper-arˆetes pour
optimiser les messages de migration sans utiliser de matrice de migration calcul´ee `a l’avance.
Les m´ethodes de partitionnement biais´e mettent en ´evidence les limites des bissections r´ecursives
utilis´ees dans les partitionneurs usuels. Un module de partitionnement k-aire utilisant une
heuristique de greedy graph growing est ajout´ee dans le partitionneur Scotch pour am´eliorer la
qualit´e de nos partitionnements.2.4. POSITIONNEMENT 23 Méthode d'appariement (Matching) Méthode de la chaîne (1D) Méthode gloutonne (Greedy) Méthode de partitionnement biaisé (Biased) Méthode diffusive (Diff) Hyper-arêtes de repartitionnement Matrice de migration Graphe quotient Nouvelle partition en N Graphe partitionné en M Construction de la matrice de migration M×N Repartitionnement M×N Programme linéaire (LP) Figure 2.12 – Vue d’ensemble de nos m´ethodes de repartitionnement M × N.24 CHAPITRE 2. ETAT DE L’ART ´Chapitre 3
Mod`ele de migration pour le
repartitionnement M × N
Sommaire
3.1 Notations et d´efinitions . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.1.1 G´en´eralit´es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.1.2 D´efinitions pour le repartitionnement M × N . . . . . . . . . . . . . . 27
3.2 Matrices de migration optimales dans le cas ´equilibr´e . . . . . . . 28
3.3 Construction des matrices de migration . . . . . . . . . . . . . . . . 35
3.3.1 M´ethode bas´ee sur la chaˆıne (1D) . . . . . . . . . . . . . . . . . . . . . 35
3.3.2 M´ethode d’appariement (Matching) . . . . . . . . . . . . . . . . . . . 42
3.3.3 M´ethode gloutonne (Greedy) . . . . . . . . . . . . . . . . . . . . . . . 47
3.3.4 Programme lin´eaire (LP) . . . . . . . . . . . . . . . . . . . . . . . . . 58
3.4 Evaluation des m´ethodes et conclusion . . . . . . . . . . . . . . . . 62 ´
La premi`ere ´etape de notre m´ethode de repartitionnement consiste `a construire une matrice
de migration optimis´ee. Pour r´ealiser cela, il n’est pas n´ecessaire de disposer de toute l’information
sur le graphe partitionn´e mais seulement du graphe quotient. Nous proposons plusieurs
algorithmes permettant de construire des matrices de migration optimisant diff´erents crit`eres.
Cette ´etape est r´esum´ee en figure 3.1.
Dans un premier temps, nous ´enoncerons quelques d´efinitions g´en´erales sur le graphe et le
partitionnement, puis des d´efinitions particuli`eres pour nos algorithmes de repartitionnement.
Ensuite, nous ´etudierons plus en d´etails les matrices de migration dans le cas o`u l’ancienne
partition est d´ej`a ´equilibr´ee. Enfin, nous d´ecrirons nos algorithmes de construction de matrice
de migration, avant de conclure sur une comparaison de ces diff´erents m´ethodes.
3.1 Notations et d´efinitions
Dans cette section, nous d´efinissons les notations et termes qui seront utilis´es dans cette th`ese.
Nous rappelons d’abord les d´efinitions relatives au partitionnement, puis nous introduisons les
nouvelles notations que nous utiliserons pour le repartitionnement M × N.
2526 CHAPITRE 3. MODELE DE MIGRATION `
Méthode d'appariement (Matching)
Méthode de la chaîne (1D)
Méthode gloutonne (Greedy)
Matrice de
migration
Graphe
quotient
Graphe
partitionné
en M Construction de la matrice de migration M×N
Programme linéaire (LP)
Figure 3.1 – Vue d’ensemble de nos algorithmes de construction des matrices de migration.
3.1.1 G´en´eralit´es
Soit G = (V, E), un graphe o`u V est l’ensemble des sommets et E l’ensemble des arˆetes. A`
chaque sommet v est associ´e un poids wv repr´esentant la charge de calcul associ´e `a ce sommet.
P
Une arˆete e peut avoir un poids we repr´esentant le coˆut de la communication. On notera W =
v∈V wv le poids total du graphe.
D´efinition 1 (Partition). Une k-partition P de V est un ensemble de k sous-ensembles deux `a
deux disjoints (Pi)i∈J1,kK de V tels que l’union de tous les sous-ensembles couvre V .
D´efinition 2 (Poids d’une partie). Le poids d’une partie Pi not´e w(Pi) est la somme des poids
des tous les sommets de la partie : w(Pi) = P
v∈Pi
wv.
D´efinition 3 (Partition ´equilibr´ee). La k-partition P est dite ´equilibr´ee au facteur de d´es´equilibre
ǫ ≥ 0 pr`es si ∀Pi ∈ P, w(Pi) ≤ (1 + ǫ)
W
k
.
En pratique, le facteur de d´es´equilibre souvent utilis´e est de l’ordre de quelques pour cent.
Avec un facteur de 5 % (ǫ = 0, 05), une partie qui aurait une taille id´eale de 1000 ´el´ements, ne
devra pas d´epasser 1050.
D´efinition 4 (Coupe d’un graphe). On appelle taille de la coupe (ou par abus de langage, coupe)
d’un graphe pour une partition donn´ee, le nombre d’arˆetes coup´ees ou la somme de leurs poids
si elles sont pond´er´ees. Les arˆetes coup´ees sont les arˆetes dont les deux extr´emit´es sont dans des
parties diff´erentes.
D´efinition 5 (Graphe quotient). La graphe quotient Q = G/P d’un graphe G par rapport `a la
partition P est obtenu `a partir de G en fusionnant les sommets appartenant `a une mˆeme partie
de P. Les arˆetes devenues identiques apr`es la fusion des sommets sont ´egalement fusionn´ees et
leurs poids sont additionn´es. Si les arˆetes n’´etaient pas pond´er´ees, le poids des arˆetes du graphe
quotient est le nombre d’arˆetes fusionn´ees.
Le graphe quotient Q = G/P poss`ede autant de sommets qu’il y a de parties dans P. Le poids
de chaque sommet est le poids de la partie correspondante (la somme des poids des sommets de
cette partie). Les sommets sont connect´es aux sommets correspondant aux parties voisines et le
poids des arˆetes est la somme des poids des arˆetes coup´ees entre ces deux parties.3.1. NOTATIONS ET DEFINITIONS ´ 27
(a) Partition d’un graphe en 5 parties.
4
3
2 1 4
7 7
(b) Graphe quotient correspondant `a la partition.
Figure 3.2 – Exemple de construction d’un graphe quotient pour une grille 10 × 10.
La figure 3.2 montre la partition d’un graphe issu d’une grille 2D de taille 10 × 10 et le
graphe quotient associ´e. La partition est en 5 parties et le graphe quotient poss`ede 5 sommets
colori´es de la mˆeme couleur que la partie `a laquelle il est associ´e. La partition ´etant parfaitement
´equilibr´ee, le poids de chaque sommet est ´egal, et vaut 20. Le poids des arˆetes est plus variable :
par exemple, l’arˆete entre le sommet jaunes et cyan a un poids 7, comme il y a 7 arˆetes dans le
graphe partitionn´e connectant des sommets jaunes et cyan.
3.1.2 D´efinitions pour le repartitionnement M × N
Dans le cas du repartitionnement, on distinguera deux partitions : la partition initiale P en
M parties et une partition finale d´esir´ee P
′
en N parties.
D´efinition 6 (Matrice de migration). On appelle matrice de migration, la matrice C de dimension
M × N d´ecrivant les volumes de donn´ees `a migrer entre les diff´erents parties. L’´el´ement Ci,j
correspond au nombre d’´el´ements en commun entre l’ancienne partie i et la nouvelle partie j.
C’est aussi la quantit´e de donn´ees envoy´ee par le processeur i au processeur j si i 6= j ; si i = j,
Ci,i est la quantit´e de donn´ees ne migrant pas, c’est-`a-dire restant « sur place ».
Chaque ligne repr´esente une ancienne partie, donc la somme des ´el´ements sur cette ligne est
´egale `a sa taille. De la mˆeme fa¸con, une colonne repr´esente une nouvelle partie et la somme des
´el´ements de chaque colonne est ´egale `a sa taille.
Pour ´evaluer la qualit´e des matrices de migration, nous d´efinissons plusieurs m´etriques :
TotalV et MaxV sont d´ej`a introduits par Oliker et al. [45] ; nous y ajoutons deux nouvelles
m´etriques TotalZ et MaxZ.
Le volume total de migration, not´e TotalV, est la quantit´e de sommets qui migrent (ou
la somme de leurs poids s’il sont pond´er´es). Cela correspond donc `a la somme des ´el´ements
non-diagonaux de la matrice de migration. Le volume maximum par processeur, not´e MaxV,
correspond `a la plus grande quantit´e de sommets (ou somme des poids) re¸cus et envoy´es par
un mˆeme partie. Il correspond `a la plus grande somme sur une ligne et une colonne de mˆemes
num´eros des ´el´ements hors diagonale de la matrice de migration.28 CHAPITRE 3. MODELE DE MIGRATION `
Le nombre total de messages n´ecessaires `a la migration, not´e TotalZ, correspond au nombre
de non-z´eros hors diagonale. De la mˆeme fa¸con, on d´efinit le nombre maximal de messages
(envoy´es et re¸cus) par processeur, not´e MaxZ.
TotalZ vaut au plus M × N − min(M, N) dans le cas o`u tous les ´el´ements non-diagonaux
de C sont non nuls.
La figure 3.3 montre plusieurs cas de repartitionnement de la partition initiale de la figure 3.3a.
Pour chaque repartitionnement, la matrice de migration et les diff´erentes m´etriques sont donn´ees.
Les figures 3.3b et 3.3c montrent la mˆeme nouvelle partition mais avec une num´erotation
diff´erente. Il est important de bien faire correspondre les anciennes et nouvelles parties pour avoir
une faible migration. En effet, le volume total de migration TotalV est bien plus important
dans le cas de la figure 3.3b. La figure 3.3d montre une partition diff´erente ayant une meilleure
coupe mais une migration plus ´elev´ee.
D´efinition 7 (Graphe biparti de migration). Le graphe biparti de migration est le graphe biparti
G = ((A, B), E) o`u A est l’ensemble des M anciennes parties et B l’ensemble des N nouvelles
parties. Il existe une arˆete dans E entre une ancienne et une nouvelle partie si elles partagent
des sommets. Le poids de cette arˆete est la somme des poids des sommets partag´es.
La matrice d’adjacence de ce graphe biparti est la matrice de migration C. Il existe une arˆete
entre les sommets i et j si et seulement si Ci,j est non nul et si le poids de cette arˆete vaut Ci,j .
Des exemples de graphes biparti de migration sont pr´esent´es sur la figure 3.3. Chaque arˆete du
graphe repr´esente soit un message de migration, soit les donn´ees qui restent sur place lorsque
l’arˆete relie une ancienne partie `a sa nouvelle partie associ´ee.
D´efinition 8 (Hypergraphe de repartitionnement). L’hypergraphe de repartitionnement est l’hypergraphe
comportant M sommets correspondant aux anciennes parties et N hyper-arˆetes correspondant
aux nouvelles parties. Une hyper-arˆete contient tous les sommets correspondant aux
anciennes parties avec lesquelles la nouvelle partie ´echange des sommets. Les hyper-arˆetes ne
sont pas pond´er´ees.
La matrice d’adjacence de cet hypergraphe est la matrice de migration sans prendre en compte
les valeurs : on ne s’int´eresse qu’aux z´eros et non-z´eros. Le sommet v appartient `a l’hyper-arˆete
e si et seulement si Cv,e est non nul. Chaque ligne de la matrice ou ancienne partie correspond `a
un sommet de l’hypergraphe et chaque colonne ou nouvelle partie correspond `a une hyper-arˆete.
Une hyper-arˆete contient tous les sommets dont l’´el´ement dans la matrice est non nul.
Les hypergraphes de repartitionnement correspondant `a chaque matrice de migration sont
donn´es dans la figure 3.3. La renum´erotation des parties entre les figures 3.3b et 3.3c ne change
pas l’hypergraphe de repartitionnement mais seulement les num´eros des hyper-arˆetes.
L’utilisation de ces graphes bipartis et hypergraphes permet de repr´esenter le sch´ema de
communication utilis´e lors de la migration. Les hypergraphes de repartitionnement permettent
une repr´esentation plus graphique des relations entre une ancienne et une nouvelle partition :
c’est ce que l’on constate par exemple sur la figure 3.4 en le superposant avec le graphe quotient
de l’ancienne partition.
3.2 Matrices de migration optimales dans le cas ´equilibr´e
Dans un premier temps, nous allons ´etudier les matrices de migration dans le cas particulier
o`u la partition initiale est d´ej`a parfaitement ´equilibr´ee. Plus pr´ecis´ement, on consid`ere que les
partitions initiales et finales sont parfaitement ´equilibr´ees. Dans ce cas, W doit ˆetre un multiple
commun de M et de N. On a donc W = k × ppcm(M, N) avec k un entier strictement positif.3.2. MATRICES DE MIGRATION OPTIMALES DANS LE CAS EQUILIBR ´ E´ 29
1
2
3
Coupe : 8
(a) Partition initiale d´es´equilibr´ee en 3
parties.
4 3
1 2
Coupe : 11
TotalV : 11
MaxV : 8
TotalZ : 4
MaxZ : 3
1 0 0 3
0 0 3 0
2 3 0 0
1
2
3
1
2
3
4
1
3
2
4
2
1
3
(b) Partition en 4 parties avec
une mauvaise correspondance
des parties.
1 2
4 3
Coupe : 11
TotalV : 3
MaxV : 3
TotalZ : 2
MaxZ : 2
3 0 0 1
0 3 0 0
0 0 3 2
1
2
3
1
2
3
4
1
3
2
1
3
4
2
(c) Mˆeme partition que pr´ec´edemment
mais avec une bonne
correspondance.
2
1
4
3
Coupe : 10
TotalV : 4
MaxV : 3
TotalZ : 3
MaxZ : 2
3 1 0 0
0 2 0 1
0 0 3 2
1
2
3
1
2
3
4
1
3
2
1
3
2
4
(d) Autre exemple de repartitionnement
en 4 parties.
Figure 3.3 – Exemples de repartitionnement avec les matrices de migration, graphes bipartis de
migration, hypergraphes de repartitionnement et mesures associ´ees.30 CHAPITRE 3. MODELE DE MIGRATION `
1
2
3
4
1
3
2
Figure 3.4 – Superposition de l’hypergraphe de repartitionnement de la figure 3.3c et du graphe
quotient de la partition de la figure 3.3a.
Pour simplifier notre discussion, on supposera que les poids des sommets sont unitaires. Ainsi le
probl`eme de la partition du graphe est ´equivalent `a la partition de l’entier correspondant `a son
poids.
D´efinition 9 (Matrice de migration optimale). Nous appelons matrice de migration optimale,
une matrice de migration C minimisant `a la fois le volume de total de migration (TotalV) et
le nombre de messages (TotalZ).
Lemme 1. Le volume total de migration optimal v´erifie :
TotalVopt ≥ W
1 −
min(M, N)
max(M, N)
.
D´emonstration. Il y a min(M, N) parties communes entre les partitions initiale et finale et |M −
N| parties diff´erentes. Comme les partitions sont ´equilibr´ees, les tailles des parties initiales et
finales sont respectivement W
M et W
N
. Donc au plus, min(W
M ,
W
N
) = W
max(M,N)
donn´ees restent
en place pour chaque partie commune. Le reste des donn´ees migre, donc TotalVopt ≥ W −
min(M, N) ×
W
max(M,N) = W × (1 −
min(M,N)
max(M,N)
).
Lemme 2. Une matrice de migration minimisant le nombre de messages poss`ede au moins
M + N − pgcd(M, N) coefficients non nuls. Le nombre minimal de messages v´erifie :
TotalZopt ≥ max(M, N) − pgcd(M, N).
D´emonstration. Le volume total de donn´ees est W = k × ppcm(M, N) = kaM = kbN avec a
et b deux entiers strictement positifs premiers entre eux. Chaque partie poss`ede initialement ka
sommets et finalement kb sommets.
Soit G = ((A, B), E) le graphe biparti de migration. Pour d´enombrer les ´el´ements non nuls
dans la matrice de migration, il suffit de compter le nombre d’arˆetes dans le graphe biparti de
migration.
On note (Gi = ((Ai
, Bi), Ei))i∈J1,KK
, les K composantes connexes de G. Pour chaque composante
Gi
, Mi = |Ai
| processeurs envoient Mika sommets `a Ni = |Bi
| processeurs qui re¸coivent
Nikb sommets. Dans Gi
, on a donc Wi = Mika = Nikb sommets qui sont ´echang´es, avec Mi et
Ni non nuls. Comme Wi est un multiple commun de ka et kb et comme a et b sont premiers
entre eux, le plus petit multiple commun de ka et kb est kab. Donc Wi ≥ kab. Le volume total
´echang´e W =
PK
i=1 Wi est donc sup´erieur ou ´egal `a Kkab. Autrement dit, K ≤
W
kab =
M
b
.3.2. MATRICES DE MIGRATION OPTIMALES DANS LE CAS EQUILIBR ´ E´ 31
D’autre part, on sait que MN = pgcd(M, N) × ppcm(M, N) et ppcm(M, N) = bN. On a
donc M
b = pgcd(M, N). On obtient alors K ≤ pgcd(M, N).
Comme Gi est un graphe connexe, il poss`ede au moins Mi + Ni − 1 arˆetes. Donc le nombre
total d’arˆetes |E| =
PK
i=1 |Ei
| est au moins PK
i=1 Mi +
PK
i=1 Ni − K = M + N − K. Comme
K ≤ pgcd(M, N), on obtient |E| ≥ M + N − pgcd(M, N). Le nombre de coefficients non nuls
dans la matrice de migration est donc au moins M + N − pgcd(M, N).
TotalZ est le nombre de coefficients non nuls hors de la diagonale. Il y a au plus min(M, N)
coefficients non nuls sur la diagonale. Donc TotalZ ≥ M + N − pgcd(M, N) − min(M, N) =
max(M, N) − pgcd(M, N).
B
A×B
1 2 3 4 5 6 7
1 2 3 4 5 6 7 8 9 10
A 8
11 12
ka
kb
kab
Figure 3.5 – Partitionnement d’un graphe chaˆıne en 8 et 12 parties, le motif de l’intersection
A × B permet de construire la matrice de migration « en escalier ».
Il existe diff´erentes m´ethodes pour obtenir de telles matrices avec un nombre minimal d’´el´ements
non nuls.
Une premi`ere m´ethode s’inspire du partitionnement d’un graphe « chaˆıne » ou d’un tableau,
comme pr´esent´e sur la figure 3.5. Pour compter le nombre de messages, il faut compter le nombre
d’arˆetes du graphe biparti. En reprenant les notations de la d´emonstration du lemme 2, la taille
des parties de A est ka et celle des parties de B est kb. Tous les ppcm(ka, kb) = kab sommets,
les s´eparateurs des anciennes parties et des nouvelles parties sont juxtapos´es. Le graphe biparti
de migration est coup´e en sous-graphes (composantes connexes), chacun avec b anciennes parties
de taille ka et a nouvelles parties de taille kb. Ce motif de longueur kab est donc r´ep´et´e W
kab =
M
b =
N
a = pgcd(M, N) fois. Chacun de ces sous-graphes contient b + a − 1 arˆetes. Le nombre
total d’arˆetes est donc (b + a − 1) × pgcd(M, N) = M + N − pgcd(M, N). Sur l’exemple de la
figure 3.5, on a ppcm(8, 12) = 24 donc a = 3 et b = 2. Chacune des pgcd(8, 12) = 4 composantes
connexes contient 3 + 2 − 1 = 4 arˆetes. Le graphe biparti contient 16 arˆetes. Cette construction
donne une matrice « en escalier » comme montr´e sur la figure 3.7a.
Il est ´egalement possible de construire une telle matrice r´ecursivement. On remplit la matrice
avec des blocs qui sont des matrices carr´ees diagonales de taille min(M, N), et le bloc restant
est rempli en r´ep´etant la mˆeme m´ethode sur le nouveau sous-probl`eme. Pour que la matrice soit
une matrice de migration, il faut que les sommes sur les lignes ou colonnes soient respectivement
les tailles des anciennes et nouvelles parties. Les valeurs diagonales sont donc W
max(M,N)
. La
figure 3.6 donne un exemple de telle construction dans le cas 7 × 10 avec W = 7 × 10 en trois
´etapes. Calculer le nombre de non-z´eros avec cette m´ethode, revient `a appliquer l’algorithme
d’Euclide. La division euclidienne de M par N donne M = qN + r : on commence `a remplir q
blocs carr´es de taille N × N et on recommence r´ecursivement sur le bloc restant de taille r × N32 CHAPITRE 3. MODELE DE MIGRATION `
avec r < N. L’algorithme d’Euclide donne une suite d’´equations :
M = q2N + r2 (3.1)
.
.
. (3.2)
ri−2 = qiri−1 + ri (3.3)
.
.
. (3.4)
rn−3 = qn−1rn−2 + rn−1 (3.5)
rn−2 = qnrn−1 (3.6)
avec r0 = M, r1 = N et rn−1 = pgcd(M, N). A chaque ´etape de l’algorithme, ` qiri−1 ´el´ements non
nuls sont ajout´es dans la matrice : ce sont les ´el´ements diagonaux des qi blocs carr´es. Le nombre
total d’´el´ements non nuls est donc Pn
i=2 qiri−1. En faisant la somme de toutes les ´equations
pr´ec´edentes, on obtient :
nX−2
i=0
ri =
Xn
i=2
qiri−1 +
Xn
i=2
ri (3.7)
Xn
i=2
qiri−1 = r0 + r1 − rn−1 − rn (3.8)
Xn
i=2
qiri−1 = M + N − pgcd(M, N). (3.9)
D’apr`es l’´equation 3.9, cette m´ethode construit bien une matrice avec un nombre minimal de
non-z´eros. La figure 3.7d pr´esente un exemple d’une telle matrice.
Th´eor`eme 3. Les bornes inf´erieures donn´ees dans les lemmes 1 et 2 sont atteintes. C’est-`a-dire :
TotalVopt = W
1 −
min(M, N)
max(M, N)
(3.10)
TotalZopt = max(M, N) − pgcd(M, N). (3.11)
D´emonstration. La m´ethode de construction bas´ee sur l’algorithme d’Euclide construit une matrice
de migration avec M + N − pgcd(M, N) coefficients non nuls. Les min(M, N) ´el´ements sur
la diagonale sont maximis´es et valent W
max(M,N)
. On a donc TotalV = W
1 −
min(M,N)
max(M,N)
et
TotalZ = max(M, N) − pgcd(M, N).
Proposition 4. Soient M et N deux entiers tels que M < N. Soient D une matrice diagonale
de dimension M × M dont les ´el´ements diagonaux sont W
N
et A une matrice de migration de
dimension M × (N − M) minimisant le nombre de messages. Alors, la matrice
D A
est une
matrice de migration optimale au sens de la d´efinition 9.
De mˆeme, dans le cas o`u M > N, si D est de taille N × N avec des ´el´ements diagonaux
valant W
M et si A est de taille (M − N) × N, alors
D
A
est une matrice de migration optimale.
D´emonstration. La d´emonstration est faite dans le cas M < N. La d´emonstration du cas M > N
est similaire.
La quantit´e de donn´ees qui reste sur place correspond `a la premi`ere diagonale de la matrice,
soit D. Donc, on a W M
N
donn´ees qui restent sur place, ce qui est bien le cas optimal.3.2. MATRICES DE MIGRATION OPTIMALES DANS LE CAS EQUILIBR ´ E´ 33
7
7
7
7 reste
7
7
7
10 = 1 × 7 + 3
7 3
7 3
7 3
7 3
7 3
7 3
7 reste
7 = 2 × 3 + 1
7 3
7 3
7 3
7 3
7 3
7 3
7 1 1 1
3 = 3 × 1 + 0
Figure 3.6 – Exemple de construction r´ecursive (avec les divisions euclidiennes associ´ees `a chaque
´etape) d’une matrice de migration avec un nombre minimal de communications.
D contient M ´el´ements non nuls et A contient par hypoth`ese un nombre minimal d’´el´ements
non nuls pour sa taille : M + (N − M) − pgcd(M, N − M) = N − pgcd(M, N). Le nombre total
d’´el´ements non nuls est donc M + N − pgcd(M, N) qui est bien le nombre minimal.
La matrice
D A
remplit bien les deux crit`eres pour ˆetre optimale.
La figure 3.7 pr´esente quelques exemples de matrices de migration. La matrice de la figure 3.7a
a ´et´e obtenue par la m´ethode inspir´ee du repartitionnement d’une chaˆıne qui donne une forme en
escalier. Le nombre de messages est optimal mais pas le volume de migration. Seules 12 donn´ees
restent sur place (les nombres en rouges) contre W
M × N
= 49 dans le cas d’une migration
optimale. Le volume de migration peut ˆetre am´elior´e `a l’aide d’une simple renum´erotation des
parties similaires au « remapping » de la m´ethode Scratch-Remap (cf. section 2.3). La matrice
obtenue est pr´esent´ee sur le figure 3.7b, 45 donn´ees restent alors sur place, ce qui est tr`es proche
de l’optimal.
D’apr`es le th´eor`eme pr´ec´edent, il nous suffit de combiner une matrice diagonale et une matrice
minimisant le nombre de message pour obtenir une matrice optimale. La figure 3.7c montre la
combinaison d’une matrice diagonale et d’une matrice en escalier. Dans le cas de la figure 3.7d,
on construit r´ecursivement une matrice optimale `a l’aide de matrices diagonales en se basant sur
l’algorithme d’Euclide. Bien que ces deux matrices soient optimales pour les m´etriques d´esir´ees
(TotalV et TotalZ), la matrice construite `a partir de la matrice en escalier donne un nombre
de messages par processeur (MaxZ) plus faible que la m´ethode r´ecursive.
En pratique, les partitions ne sont pas parfaitement ´equilibr´ees car cela n’est pas n´ecessaire :
on se contente d’une partition `a peu pr`es ´equilibr´ee `a un facteur de d´es´equilibre pr`es. Cette
´equilibre parfait peut mˆeme ˆetre impossible lorsque W n’est pas divisible par M ou N ou que le34 CHAPITRE 3. MODELE DE MIGRATION `
7 3
4 6
1 7 2
5 5
2 7 1
6 4
3 7
1
2
3
4
7
5
6
a
b c
d
e
f
g
h
i j
(a) Matrice « en escalier ».
7 3
6 4
1 7 2
5 5
7 1 2
6 4
7 3
1
2
3
4
7
5
6
a
h b
c
d
i
e
f
j g
(b) Matrice « en escalier » avec permutation
des colonnes pour minimiser TotalV.
7 3
7 3
7 1 2
7 3
7 2 1
7 3
7 3
1
2
3 4
5
6
7
a
b
c
d
e
f
g
h
i
j
(c) Matrice optimale utilisant une sousmatrice
en escalier.
7 3
7 3
7 3
7 3
7 3
7 3
7 1 1 1
1
2
4 3
5
6
7
a
b
c
d
e
f
g
h
i
j
(d) Exemple de matrice optimale
construite par ajout de blocs diagonaux
r´ecursivement.
Figure 3.7 – Exemples de matrices de migration pour le cas 7 × 10 et leurs repr´esentations en
hypergraphe de repartitionnement. Les ´el´ements nuls ne sont pas montr´es. Les lignes num´erot´ees
de 1 `a 7 correspondent aux sommets et les colonnes num´erot´ees de a `a j correspondent aux
hyper-arˆetes. Les ´el´ements en rouge montrent les donn´ees qui restent en place. Les ´el´ements en
noir sont ceux qui migrent, la somme de ces ´el´ements donne le volume de migration.3.3. CONSTRUCTION DES MATRICES DE MIGRATION 35
poids des sommets de permet pas un d´ecoupage en parties rigoureusement ´egales. Les r´esultats
pr´esent´es dans cette section sur le nombre de messages restent vrais pour des d´es´equilibres faibles.
En effet, il est possible de profiter de la tol´erance au d´es´equilibre des nouvelles parties pour mieux
s’adapter aux anciennes parties l´eg`erement d´es´equilibr´ees et ´economiser des messages. Le volume
de migration optimal reste proche.
Dans le cas o`u la partition initiale est fortement d´es´equilibr´ee, il est difficile de donner des valeurs
optimales pour tous les cas. Il est toujours possible d’effectuer la migration en max(M, N)−1
messages (le nombre minimal d’arˆetes d’un graphe biparti connexe ´etant M + N − 1), mais ce
nombre n’est pas toujours minimal.
3.3 Construction des matrices de migration
3.3.1 M´ethode bas´ee sur la chaˆıne (1D)
a) Cas ´equilibr´e
Dans le cas d’une partition initiale ´equilibr´ee, la m´ethode la plus simple pour construire une
matrice de migration permettant `a la fois une bonne migration (m´etriques TotalV, MaxV,
TotalZ et MaxZ) et une bonne coupe, consiste `a r´eutiliser le principe du partitionnement de
la chaˆıne pr´esent´ee dans la section 3.2.
De telles matrices de migration peuvent ˆetre obtenues `a l’aide d’un repartitionnement bas´e sur
des courbes de remplissage ou space filling curve (SFC) [52,54]. Ce repartitionnement g´eom´etrique
construit une courbe remplissant l’espace `a partitionner, comme par exemple `a l’aide d’une courbe
de Hilbert [54] (cf. figure 3.8). On peut facilement obtenir une partition en M parties en coupant
cette courbe en M sections ´egales. Si on construit une nouvelle partition en N parties en utilisant
la mˆeme courbe de remplissage, on obtient un repartitionnement bas´e sur la chaˆıne (la chaˆıne
´etant la courbe de remplissage). Cette m´ethode a l’inconv´enient de n´ecessiter des informations
g´eom´etriques sur les donn´ees `a partitionner et donne une coupe assez ´elev´ee `a cause de la nature
fractale des courbes utilis´ees.
Pour appliquer le principe du partitionnement de la chaˆıne sur un graphe quelconque, il
suffit de trouver un chemin dans le graphe quotient. L’utilisation du graphe quotient au lieu du
graphe `a partitionner permet de laisser `a une heuristique de partitionnement classique le choix
de la distribution des sommets. Ainsi, le probl`eme de coupe des courbes de remplissage est r´egl´e
tout en gardant le mˆeme sch´ema de communication. Le chemin de M sommets dans le graphe
quotient est alors d´ecoup´e en N nouvelles parties, un sommet (correspondant `a une ancienne
partie) pouvant ˆetre partag´e entre plusieurs nouvelles parties. Le choix de ce chemin influence
directement la coupe de la partition finale. En effet, comme une nouvelle partie peut prendre
des sommets de plusieurs anciennes parties cons´ecutives dans ce chemin, il est pr´ef´erable que ces
parties soient bien connect´ees entre elles. Il faudra donc trouver un chemin dont les arˆetes ont
des poids ´elev´es dans le graphe quotient.
Pour optimiser la migration, une renum´erotation des nouvelles parties est n´ecessaire, car en
num´erotant les parties dans l’ordre du chemin, les num´eros sont d´ecal´es par rapport `a la partition
initiale comme on peut le voir sur la figure 3.9. L’utilisation d’un chemin peut aussi ˆetre vue
comme une renum´erotation des anciennes parties apr`es laquelle on applique le repartitionnement
de la chaˆıne sur le nouvel ordre des parties. Donc, deux renum´erotations sont en fait n´ecessaires :
l’une permutant les anciennes parties (ou lignes de la matrice de migration) en fonction du
chemin, l’autre permutant les nouvelles parties (ou colonnes de la matrice de migration) pour
optimiser la migration.36 CHAPITRE 3. MODELE DE MIGRATION `
(a) Partitionnement en 3. (b) Partitionnement en 5.
13 8
5 12 5
8 13
(c) Matrice de migration.
Figure 3.8 – Partitionnement et repartitionnemnent d’une grille 8 × 8 bas´es sur une courbe de
remplissage de Hilbert.
B
1 2 3 4 5 6 7
1 2 3 4 5 6 7 8 9 10
A 8
11 12
(a) Num´erotation des nouvelles parties dans l’ordre du chemin.
B
1 2 3 4 5 6 7
1 9 2 3 10 4 5 11 6 7
A 8
12 8
(b) Renum´erotation pour optimiser la migration.
Figure 3.9 – Exemple de num´erotations des nouvelles parties. Les arˆetes en pointill´es correspondent
aux « communications » d’un processeur vers lui-mˆeme. Les donn´ees qui ne migrent pas
sont en gris clair.3.3. CONSTRUCTION DES MATRICES DE MIGRATION 37
Nœud courant Partie suivante
Partie précédente
Figure 3.10 – Exemple d’´etape de l’algorithme de recherche de chemin `a partir de l’arbre des
bissections. La zone verte contient les nœuds dont l’ordre est d´ej`a fix´e, la zone rouge ceux dont
on ne connait pas encore l’ordre. Le choix de l’ordre est `a faire entre les deux sommets de la zone
bleue claire.
La recherche d’un tel chemin dans le graphe quotient est un probl`eme analogue `a celui du
voyageur de commerce, qui est NP-complet [20, TRAVELING SALESMAN].
Il existe de nombreuses m´ethodes pour obtenir des chemins non optimaux mais assez proches
de l’optimal, comme par exemple des algorithmes probabilistes. Mais certains « bons » chemins
peuvent cr´eer des probl`emes dans le cas d’un partitionnement par bissections r´ecursives. En effet,
une bissection devra couper ce chemin en deux en mˆeme temps que le graphe. La bissection du
chemin est forc´ee par la num´erotation des nouvelles parties : elle s´epare les plus petits num´eros
des plus grands. Une bissection du chemin par le milieu doit donc laisser la possibilit´e d’une
bonne bissection du graphe.
Dans le cas o`u la partition initiale a ´et´e r´ealis´ee par un partitionneur utilisant des bissections
r´ecursives, l’arbre des bissections peut ˆetre utilis´e pour trouver rapidement un chemin. Les parties
issues d’une bissection r´ecursive sont num´erot´ees dans l’ordre des feuilles. Les nœuds internes
repr´esentent l’union des parties dans le sous-arbre. A l’aide d’un parcours en largeur de l’arbre, `
chaque nœud interne est visit´e. L’ordre de ses deux fils est choisi de fa¸con `a maximiser les
connexions avec les parties (ou unions de parties) pr´ec´edentes et suivantes. Comme tout l’arbre
n’a pas encore ´et´e visit´e, l’ordre de toutes les parties n’a pas encore ´et´e d´ecid´e. On prend donc la
partie pr´ec´edente au mˆeme niveau dans l’arbre et la partie suivante au niveau sup´erieur comme
indiqu´e sur la figure 3.10.
La figure 3.12 pr´esente un exemple d’ex´ecution de cet algorithme sur le graphe quotient de
la figure 3.11. L’arbre initial est celui de la figure 3.12a. Au niveau de la racine, il n’y a pas de
choix `a faire car il n’y a ni partie pr´ec´edente ni suivante. Le premier choix arrive avec le nœud
unissant 0 et 1. La partie suivante est 2–4 dont la connexion avec 0 est 39 + 14 = 53 et celle avec
1 est 17 + 34 = 51. La partie 0 est donc plac´ee en second comme indiqu´e sur la figure 3.12b. Sur
la figure 3.12c, les connexions des parties 2 et 3–4 avec la partie pr´ec´edente 0 sont compar´ees.
Enfin, les connexions des parties 3 et 4 avec les parties pr´ec´edente 0 et suivante 2 sont compar´ees,
et l’ordre est conserv´e (figure 3.12d).
En pratique, pour am´eliorer la qualit´e du chemin en gardant un algorithme rapide, toutes les
solutions possibles sont recherch´ees quand on arrive sur un sous-arbre suffisamment petit.
Une fois la nouvelle partition obtenue, il faut renum´eroter les parties pour optimiser la migration
comme montr´e sur la figure 3.9. De la mˆeme fa¸con que le Scratch-Remap, il faut chercher
la meilleure association entre anciennes et nouvelles parties. Mais dans le cas du partitionnement38 CHAPITRE 3. MODELE DE MIGRATION `
39
39
14
34
17
62
65
0
1
2
3
4
Figure 3.11 – Exemple de partition initiale en 5 partie et du graphe quotient associ´e.
de la chaˆıne, le choix est plus simple :
— si M < N, pour chaque ancienne partie, on choisit la nouvelle partie qui re¸coit le plus de
donn´ees ;
— si M > N, pour chaque nouvelle partie, on choisit l’ancienne partie qui lui en envoie le
plus.
Les nouvelles parties qui ne sont pas associ´ees `a une ancienne prennent alors de nouveaux
num´eros qui n’existaient pas dans l’ancienne partition : ce sont les N − M plus grands.
On peut v´erifier par l’absurde que ces choix sont possibles dans le cas M < N. Cette m´ethode
de renum´erotation poserait probl`eme si et seulement si une mˆeme nouvelle partie est le meilleur
choix pour deux anciennes. Si une ancienne partie partage des donn´ees avec trois ou plus nouvelles
parties, une de ces nouvelles parties ne re¸coit des donn´ees que de cette ancienne partie et ne serait
le meilleur choix que pour celle-ci. Ces deux anciennes parties n’ont donc chacune des donn´ees
partag´ees qu’avec deux nouvelles : les nouvelles parties ´etant plus petites, il y en a au moins
deux. La nouvelle partie qui serait le meilleur choix pour les deux anciennes doit donc recevoir
plus de la moiti´e des donn´ees de chacune des deux anciennes parties. Elle serait donc plus grande
que les anciennes, ce qui est en contradiction avec l’hypoth`ese M < N.
On peut faire un raisonnement similaire dans le cas M > N, en inversant les rˆoles des
anciennes et nouvelles parties.
b) Illustration dans le cas ´equilibr´e
La figure 3.13 pr´esente un exemple de repartitionnement dans le cas o`u il y a 5 parties
initiales ´equilibr´ees (1400 ´el´ements chacune) et 7 parties finales qui doivent contenir 1000 ´el´ements
chacune pour ˆetre ´equilibr´ees. On commence par construire une matrice correspondant au
repartitionnement de la chaˆıne comme pr´esent´e dans la section 3.2 (matrice en escalier) :
1000 400 0 0 0 0 0
0 600 800 0 0 0 0
0 0 200 1000 200 0 0
0 0 0 0 800 600 0
0 0 0 0 0 400 1000
3.3. CONSTRUCTION DES MATRICES DE MIGRATION 39
0–4
0–1 2–4
0 1 2 3–4
3 4
(a) Arbre de bissections initial.
0–4
0–1 2–4
1 0 2 3–4
3 4
(b) Permutation de 0 et 1.
0–4
0–1 2–4
1 0 3–4
3 4
2
(c) Permutation de 2 et 3–4.
0–4
0–1 2–4
1 0 3–4
3 4
2
(d) L’ordre entre 3 et 4 est pr´eserv´e.
Figure 3.12 – Exemple de recherche de chemin par permutation de l’arbre des bissections.
Ensuite, un chemin est recherch´e dans le graphe, maximisant la connexion entre les sommets
successifs (les anciennes parties). Ici, le chemin choisi est 1, 0, 3, 4 et 2. Les lignes de la matrice
sont permut´ees en cons´equence. Enfin, il faut renum´eroter les nouvelles parties pour minimiser
le volume de migration. On choisit les nouvelles parties recevant le plus d’´el´ements des anciennes
parties. Les nouvelles parties correspondant aux anciennes 1, 0, 3, 4 et 2, sont respectivement
0, 2, 3, 4 et 6. Renum´eroter les nouvelles parties revient `a permuter les colonnes de la matrice
de migration. Les nouvelles parties non associ´ees aux anciennes (1 et 5) prennent de nouveaux
num´eros, ici 5 et 6. Les colonnes sont permut´ees en cons´equence, les colonnes suppl´ementaires (5
et 6) peuvent ˆetre dans un ordre quelconque.
La figure 3.14 pr´esente les hypergraphes de repartitionnement dans trois cas de repartitionnement.
Dans les cas ou les nombres de parties initial et final ne sont pas premiers entre eux
(8×12 et 12×14), les chemins sont coup´es en plusieurs parties : ce sont les composantes connexes
utilis´ees dans la d´emonstration du lemme 2. On remarque ´egalement que les hyper-arˆetes sont
de petites tailles et regroupent des anciennes parties voisines comme on le souhaitait.
c) G´en´eralisation au cas d´es´equilibr´e
Cette m´ethode peut ˆetre facilement adapt´ee dans le cas o`u la partition initiale est d´es´equilibr´ee.
Il faut d’abord trouver un chemin dans le graphe quotient. Ensuite, connaissant cet ordre
des parties, il suffit de le red´ecouper en parties de tailles ´egales. Dans le cas d´es´equilibr´e, toutes40 CHAPITRE 3. MODELE DE MIGRATION `
39
39
14
34
17
62
65
800 0 0 0 0 0 600
0 1000 0 0 0 0 400
0 0 1000 0 0 400 0
200 0 0 1000 200 0 0
0 0 0 0 800 600 0
TotalV = 2400
MaxV = 1000
TotalZ = 6
MaxZ = 2
Figure 3.13 – Exemple de repartitionnement bas´e sur la chaˆıne dans le cas 5×7 (cas ´equilibr´e).
52
22
49
5
26
47
6
50
51
8
24
22
51
(a) Hypergraphe de repartitionnement
dans le cas 8 × 12.
26 21
17
32
26 23
30
12
28
27
40
30
3
9
29
19
22
21
25
21
17
29
29
(b) Hypergraphe de repartitionnement
dans le cas 12 × 14.
27
20
24 4
23
4
5
30 23
21
5
25
21
25
8
21
21
4
25
29
26
10 24
8 26
23
20
28
4 23
23
24
23
(c) Hypergraphe de repartitionnement
dans le cas 16 × 21.
Figure 3.14 – Applications du repartitionnement bas´e sur la chaˆıne dans le cas ´equilibr´e.3.3. CONSTRUCTION DES MATRICES DE MIGRATION 41
900 500 1500 1700 2400
1000
1 0 3 4 2
1 0 3 4 6 2 5
39
39
14
34
17
62
65
400 100 0 0 0 0 0
0 900 0 0 0 0 0
0 0 1000 0 0 1000 400
600 0 0 900 0 0 0
0 0 0 100 1000 0 600
TotalV = 2800
MaxV = 1400
TotalZ = 6
MaxZ = 2
Figure 3.15 – Exemple de repartitionnement bas´e sur la chaˆıne dans le cas 5×7 (cas d´es´equilibr´e).
les parties ne se valent pas. La forme de l’hypergraphe de repartitionnement utilis´e peut varier
suivant l’ordre choisi.
Par exemple, consid´erons le cas 5 × 7 o`u les parties sont initialement d´es´equilibr´ees avec
comme poids dans l’ordre de 0 `a 4 : 500, 900, 2400, 1500 et 1700. En reprenant le mˆeme chemin 1
que dans le cas ´equilibr´e (figure 3.12), l’ordre des poids devient 900, 500, 1500, 1700 et 2400, et
on obtient le repartitionnement pr´esent´e sur la figure 3.15.
La figure 3.16 pr´esente alors les hypergraphes de repartitionnement obtenus avec la m´ethode
de la chaˆıne dans le cas d´es´equilibr´e. Contrairement au cas ´equilibr´e, il n’est plus garanti que
certaines s´eparations entre parties soient communes entre l’ancienne partition et la nouvelle. Le
nombre de messages peut donc atteindre, au pire, M+N −1 messages. On peut voir que les hyperarˆetes
forment les mˆemes chemins que ceux de la figure 3.14 mais « sans ˆetre coup´ees ». Dans
le cas ´equilibr´e, le chemin ´etait d´ecoup´e en pgcd(M, N) parties correspondant aux composantes
connexes du graphe biparti de repartitionnement utilis´ees dans la section 3.2.
1. Le chemin ne d´epend que de la connectivit´e du graphe quotient, pas du poids de ses sommets.42 CHAPITRE 3. MODELE DE MIGRATION `
52
22
49
5
26
47
6
50
51
8
24
22
51
(a) Hypergraphe de repartitionnement
dans le cas 8 × 12.
26 21
17
32
26 23
30
12
28
27
40
30
3
9
29
19
22
21
25
21
17
29
29
(b) Hypergraphe de repartitionnement
dans le cas 12 × 14.
27
20
24 4
23
4
5
30 23
21
5
25
21
25
8
21
21
4
25
29
26
10 24
8 26
23
20
28
4 23
23
24
23
(c) Hypergraphe de repartitionnement
dans le cas 16 × 21.
Figure 3.16 – Applications du repartitionnement bas´e sur la chaˆıne dans le cas d´es´equilibr´e.
3.3.2 M´ethode d’appariement (Matching)
Dans le cas ´equilibr´e, nous avons vu en section 3.2 qu’il est possible de construire des matrices
de migration optimales, c’est-`a-dire optimisant `a la fois le volume de migration et le nombre de
messages. Mais l’optimisation de la coupe n’est pas consid´er´ee. Comme on l’a vu avec la m´ethode
de la chaˆıne, il peut ˆetre n´ecessaire de permuter la matrice de migration pour obtenir une bonne
coupe. Mais une matrice optimale ne correspond pas toujours `a une chaˆıne : il ne suffit plus
de trouver un bon chemin dans le graphe quotient. On cherche donc `a apparier correctement la
matrice de migration avec le graphe quotient pour que la partition finale ait une bonne coupe.
Comme les valeurs des ´el´ements de la matrice de migration n’influencent pas cet appariement,
nous utiliserons l’hypergraphe de repartitionnement dans cette section.
Le choix de la matrice de migration ou de l’hypergraphe repartitionnement conditionne la
qualit´e de la migration. Nous d´ecidons de prendre une matrice de migration optimale (d’apr`es
la d´efinition 9), plus pr´ecis´ement la matrice optimale compos´ee d’une diagonale et compl´et´ee
avec une sous-matrice « chaˆıne » (comme celle de la figure 3.7c). En plus de minimiser T otalV
et T otalZ, cette matrice a l’avantage de garder un M axZ plus faible que les autres matrices
optimales.
a) Probl`eme d’appariement entre le graphe quotient et l’hypergraphe de repartitionnement
Une bonne matrice de migration ne suffit donc pas pour obtenir un bon repartitionnement.
Elle ne permet que d’optimiser la migration et l’´equilibre. Un bon repartitionnement doit aussi
fournir une coupe basse. La coupe sera principalement d´ecid´ee lors de l’´etape de repartitionnement,
mais la matrice de migration a une influence sur la coupe. Une matrice de migration
indique l’emplacement des nouvelles parties : elles seront l`a o`u se trouvent les anciennes parties
dont elles prennent les sommets. Pour permettre au partitionneur de bien optimiser la coupe, il
faut que les anciennes parties communiquant avec une mˆeme nouvelle partie soient proches.
Pour obtenir ce r´esultat, on apparie l’hypergraphe de repartitionnement avec le graphe quotient,
c’est-`a-dire qu’on cherche une correspondance entre les sommets de l’hypergraphe et ceux
du graphe quotient comme pr´esent´e sur la figure 3.17. En effet, les hyper-arˆetes regroupent les
anciennes parties donnant des sommets `a une mˆeme nouvelle partie, alors que les arˆetes du graphe
quotient connectent les anciennes parties proches.3.3. CONSTRUCTION DES MATRICES DE MIGRATION 43
1
2
3
4
5
6
7
7
2
1
4
3
6
5
Figure 3.17 – Appariement d’un graphe quotient et d’un hypergraphe de repartitionnement.
Par exemple, il y a plusieurs fa¸cons d’apparier l’hypergraphe de repartitionnement pour repartitionner
la partition initiale d’un maillage en grille visible sur la figure 3.18a. Les figures 3.18b
et 3.18c pr´esentent deux possibilit´es d’appariement de l’hypergraphe de repartitionnement en
le superposant au graphe quotient. Dans le premier cas, les hyper-arˆetes regroupant plusieurs
sommets contiennent des sommets « proches » organis´es en cliques. En cons´equence la partition
finale sur la figure 3.18d a des parties bien form´ees, alors que, dans le second cas, les hyper-arˆetes
regroupent des sommets « ´eloign´es » et la partition finale sur la figure 3.18e a des parties d´econnect´ees
sur le maillage. Les m´etriques pour ´evaluer la migration (TotalV, MaxV, TotalZ et
MaxZ) sont les mˆemes dans ces deux cas, mais la coupe du graphe est bien meilleure dans le
premier cas.
Pour ´eviter de tels sc´enarios, une m´etrique suppl´ementaire est introduite pour estimer la
qualit´e de la coupe finale. Cette m´etrique doit favoriser les nouvelles parties prenant des donn´ees
`a un ensemble d’anciennes parties bien connect´ees, autrement dit des quasi-cliques. Cette
m´etrique s’exprime `a l’aide du graphe quotient de l’ancienne partition et de l’hypergraphe de
repartitionnement.
b) D´efinition d’un score d’appariement
Une fois la matrice choisie, il faut trouver une bonne correspondance entre les sommets
du graphe quotient et ceux de l’hypergraphe de repartitionnement associ´e `a la matrice. Cet
appariement n´ecessite la d´efinition d’un score.
Notons Q = (VQ, EQ) le graphe quotient par rapport `a l’ancienne partition, H = (VH, EH)
l’hypergraphe de repartitionnement d´ej`a appari´e (on consid`ere que les sommets de Q et de H
sont les mˆemes, on pose V = VQ = VH) et ES(e) l’ensemble des arˆetes du sous-graphe de Q
induit par l’hyper-arˆete e. Une premi`ere version simple de ce score compte la somme des poids
des arˆetes des sous-graphes induits par chaque hyper-arˆete e :
Score = X
e∈EH
X
e
′∈ES (e)
we
′
(3.12)
o`u ES(e) = {(i, j) ∈ EQ : i ∈ e ∧ j ∈ e} .44 CHAPITRE 3. MODELE DE MIGRATION `
(a) Hypergraphe de repartitionnement et partition initiale.
(b) Exemple de bonne correspondance. (c) Exemple de mauvaise correspondance.
(d) La partition est bien form´ee. (e) Certaines parties sont d´econnect´ees.
Figure 3.18 – Deux cas d’application d’un mˆeme hypergraphe de repartitionnement.3.3. CONSTRUCTION DES MATRICES DE MIGRATION 45
Il est possible d’´ecrire ce score sous forme matricielle. Notons X la matrice d’appariement (ou
de permutation) de taille M × M `a trouver : Xi,i′ vaut 1 si et seulement si le sommet i de
l’hypergraphe de repartitionnement est associ´e au sommet i
′ du graphe quotient, sinon 0. La
matrice H repr´esente l’hypergraphe de repartitionnement 2
. Elle est de taille M × N et Hi,j vaut
1 si est seulement si le sommet i est inclus dans l’hyper-arˆete j. Q est la matrice d’adjacence
du graphe quotient de taille M × M, Qi,j est le poids de l’arˆete entre les sommets i et j. Ces
notations sont r´esum´ees sur la figure 3.19.
i'
j'
j
i
k
Qi',j'
Xi,i' = 1
Xj,j' = 1
Figure 3.19 – Illustration des notations utilis´ees dans la formule de score avec une arˆete (i
′
, j′
)
du graphe quotient Q `a gauche et une hyper-arˆete k `a droite.
Grˆace aux matrices `a valeurs binaires X et H, on peut ´ecrire la somme du poids des arˆetes
ei
′
,j′ dont les extr´emit´es i
′
et j
′
sont respectivement associ´ees `a deux sommets i et j dans la
mˆeme hyper-arˆete k :
Score = X
i,j,i′
,j′
,k
Xi,i′Xj,j′Hi,kHj,kQi
′
,j′ soit (3.13)
Score = X
i,i′
Xi,i′
X
j,j′
Xj,j′
X
k
Hi,kHj,k!
Qi
′
,j′
!
. (3.14)
D´efinition 10 (Produit de Kronecker). Le produit de Kronecker de deux matrices A ⊗ B, A de
taille m × n et B de taille m′ × n
′
, est une matrice de taille mm′ × nn′
, d´ecrite par la matrice
bloc suivante :
A1,1B · · · A1,nB
.
.
.
.
.
.
.
.
.
Am,1B · · · Am,nB
.
En notant A = HHT ⊗ Q, o`u ⊗ est le produit de Kronecker, et x le vecteur colonne de taille
M2
tel que xiM+i
′ = Xi,i′ , le score s’´ecrit comme la forme quadratique :
Score = x
T Ax. (3.15)
Dans l’´equation 3.14, on reconnait le coefficient de la matrice A = HHT ⊗ Q :
AiM+i
′
,jM+j
′ =
X
k
Hi,kHj,k!
Qi
′
,j′ ,
2. Par abus de langage, on confond les graphes et hypergraphes avec leurs matrices d’adjacence.46 CHAPITRE 3. MODELE DE MIGRATION `
20 20
(a) Chaine de 3 parties r´eunies dans une mˆeme
hyper-arˆete. Les deux parties aux extr´emit´es
sont ´eloign´ees l’une de l’autre.
15 20
5
(b) Clique de 3 parties r´eunies dans une mˆeme
hyper-arˆete.
Figure 3.20 – Deux exemples de sous-graphes quotients appari´es avec une hyper-arˆete.
P
k Hi,kHj,k correspondant au coefficient (i, j) de la matrice HHT
.
Cette m´etrique favorise les hyper-arˆetes regroupant des sommets fortement connect´es. Mais
elle est loin d’ˆetre parfaite, car elle ne prend pas en compte le nombre d’arˆetes du graphe quotient
associ´ees `a une hyper-arˆete. A score ´egal, il apparait plus avantageux de favoriser trois sommets `
connect´es par trois arˆetes plutˆot que par deux.
Sur l’exemple de la figure 3.20, les deux appariements d’une hyper-arˆete avec un graphe de
3 sommets ont le mˆeme score : 40. Pourtant, dans le cas de la figure 3.20a, les deux parties aux
extr´emit´es de la chaˆıne peuvent ˆetre ´eloign´ees et la nouvelle partie cr´e´ee devra alors ˆetre ´etir´ee,
ce qui n’est pas optimal pour la coupe. On pr´ef´ererait favoriser les cas de cliques comme sur la
figure 3.20b, o`u les 3 parties sont bien regroup´ees.
Pour corriger ces d´efauts, nous allons modifier le score pour prendre en compte la quantit´e
d’arˆetes et la taille des hyper-arˆetes 3
. On propose la nouvelle formule de score suivante. Soient
ES(e) l’ensemble des arˆetes du sous-graphe induit par l’hyper-arˆete e et K(e) l’ensemble des
arˆetes d’une clique entre les sommets de l’hyper-arˆete e. La m´etrique s’exprime :
ScoreR =
X
e∈EH
|ES(e)|
|K(e)|
X
e
′∈ES (e)
we
′
(3.16)
o`u
ES(e) = {(i, j) ∈ EQ : i ∈ e ∧ j ∈ e}
K(e) =
(i, j) ∈ V
2
: i 6= j ∧ i ∈ e ∧ j ∈ e
.
En reprenant l’exemple 3.20, les anciens scores sont multipli´es par 2/3 dans le cas de la chaˆıne
(fig. 3.20a) et par 1 dans le cas de la clique (fig. 3.20b), ce qui donne les scores 26 et 40 : la clique
est maintenant favoris´ee par rapport `a la chaˆıne.
c) Choix d’un appariement par une m´ethode d’optimisation du score
Afin de choisir un bon appariement, nous allons utiliser une m´ethode d’optimisation du score
d´efini pr´ec´edemment.
La maximisation de l’´equation 3.15 est un probl`eme d’optimisation quadratique `a valeurs
binaires. C’est un probl`eme NP-difficile [20, QUADRATIC PROGRAMMING] mais d´ej`a beaucoup
´etudi´e, en particulier dans le domaine de la vision num´erique [15,41]. Une premi`ere solution
consiste `a utiliser une m´ethode spectrale. Comme x
T x = M est une constante, maximiser revient
3. On rappelle que la taille d’une hyper-arˆete est le nombre de sommets qu’elle regroupe.3.3. CONSTRUCTION DES MATRICES DE MIGRATION 47
`a maximiser le quotient de Rayleigh-Ritz [25] x
T Ax
xT x
. Dans le cas o`u x est `a coefficient r´eels, ce
quotient atteint son maximum pour un vecteur propre associ´e `a la plus grande valeur propre.
Mais ici x est `a valeur binaire, et la relaxation du probl`eme ne donne pas de solution convenable.
En effet, approcher le vecteur propre avec un vecteur correspondant `a une permutation est une
approximation trop importante.
D’autres heuristiques pour trouver un bon appariement sont possibles, comme par exemple
des algorithmes probabilistes, combinatoires de type branch & bound, ... Nous avons choisi d’utiliser
un algorithme de recuit simul´e [40] qui donne des r´esultats satisfaisants. En partant d’une
correspondance quelconque, des permutations de deux sommets al´eatoires sont appliqu´ees. Si la
nouvelle correspondance a un meilleur score, elle est conserv´ee. Sinon, elle est conserv´ee ou non
avec une probabilit´e qui d´ecroit exponentiellement avec le nombre d’it´erations. Apr`es un nombre
d’it´erations fix´e, l’algorithme s’arrˆete. Cette m´ethode peut s’appliquer `a n’importe quelle forme
de score et notamment `a la formule du score 3.16.
d) Illustration de la m´ethode de matching
La figure 3.21 pr´esente un exemple de repartitionnement bas´e sur le matching. Dans un premier
temps, une matrice de migration optimale est choisie. Ici, on choisit une matrice combinant
une sous-matrice diagonale avec une sous-matrice en escalier dont l’hypergraphe de repartitionnement
associ´e est repr´esent´e dans la figure 3.21a. Cette classe de matrice a l’avantage de fournir
un nombre de messages par partie souvent plus faible que les matrices construites r´ecursivement
(cf. section 3.2). Ensuite, cet hypergraphe de repartitionnement est mis en correspondance
avec le graphe quotient `a l’aide de l’heuristique de recuit simul´e optimisant la fonction ScoreR
(´equation 3.16). Le r´esultat est visible sur la figure 3.21b. Cette appariement correspond `a une
permutation des lignes de la matrice mais aussi des 5 premi`eres colonnes pour garder une diagonale
optimisant le volume de migration.
La figure 3.22 pr´esente des r´esultats d’application de la m´ethode d’appariement dans diff´erents
cas. On remarque que dans le cas 8×12 (figure 3.22a), le r´esultat est le mˆeme qu’avec la m´ethode
de la chaˆıne. En effet, les matrices 8×12 choisies dans les deux m´ethodes sont ´equivalentes `a une
permutation pr`es dans ce cas pr´ecis. Dans le cas 12×14 (figure 3.22b), il y a de tr`es grandes hyperarˆetes.
Cela risque de poser probl`eme pour la construction des parties associ´ees `a ces grandes
hyper-arˆetes. Ce probl`eme vient du choix de la matrice optimale qui concentre les non-z´eros dans
les derni`eres colonnes de la matrice. Cela aurait pu ˆetre ´evit´e en choisissant un autre type de
matrice, mais le volume total de migration n’aurait pas ´et´e optimal. Le recuit simul´e ne trouve
pas toujours de bonne solution : sur la figure 3.22c, l’hyper-arˆete contenant les sommets 0, 4, 7 et
15 ne contient que deux arˆetes (4–7 de poids 25 et 0–15 de poids 4), mais les autres hyper-arˆetes
sont assez bien plac´ees.
Notons que cette m´ethode de repartitionnement ne peut pas ˆetre appliqu´ee dans le cas o`u les
parties sont initialement d´es´equilibr´ees. La mise en correspondance de l’hypergraphe de repartitionnement
et du graphe quotient n´ecessite que les parties initiales soient interchangeables, ce
qui n’est le cas que quand les parties initiales ont toutes le mˆeme poids.
3.3.3 M´ethode gloutonne (Greedy)
Dans le cas g´en´eral, il n’est pas possible de choisir une matrice avant de l’apparier au graphe
quotient : les anciennes parties ont chacune un poids diff´erent et elles ne sont plus interchangeables.
Il faut construire la matrice de migration directement en tenant compte de la connectivit´e
entre les parties et de leurs diff´erents poids.48 CHAPITRE 3. MODELE DE MIGRATION `
1000 0 0 0 0 400 0
0 1000 0 0 0 400 0
0 0 1000 0 0 200 200
0 0 0 1000 0 0 400
0 0 0 0 1000 0 400
(a) Matrice de migration optimale et hypergraphe de repartitionnement associ´e pour le cas 5 × 7.
39
39
14
34
17
62
65
1000 0 0 0 0 0 400
0 1000 0 0 0 400 0
0 0 1000 0 0 400 0
0 0 0 1000 0 0 400
0 0 0 0 1000 200 200
TotalV = 2000
MaxV = 1000
TotalZ = 6
MaxZ = 3
(b) Hypergraphe appari´e au graphe quotient et matrice de migration finale.
Figure 3.21 – Exemple de repartitionnement bas´e sur le matching dans le cas 5 × 7.3.3. CONSTRUCTION DES MATRICES DE MIGRATION 49
52
22
49
5
26
47
6
50
51
8
24
22
51
(a) Hypergraphe de repartitionnement
dans le cas 8 × 12.
26 21
17
32
26 23
30
12
28
27
40
30
3
9
29
19
22
21
25
21
17
29
29
(b) Hypergraphe de repartitionnement
dans le cas 12 × 14.
27
20
24 4
23
4
5
30 23
21
5
25
21
25
8
21
21
4
25
29
26
10 24
8 26
23
20
28
4 23
23
24
23
(c) Hypergraphe de repartitionnement
dans le cas 16 × 21.
Figure 3.22 – Application du repartitionnement bas´e sur le matching.
a) Construction de la matrice de migration par une m´ethode gloutonne
La matrice de migration C est construite par l’algorithme 2 selon une m´ethode gloutonne en
prenant en entr´ee le graphe quotient Q = (V, E) et le nouveau nombre de parties N. On note
(Pi)i∈J0,M−1K
les anciennes parties et (P
′
j
)j∈J0,N−1K
les nouvelles parties. L’algorithme commence
avec une matrice vide, puis les colonnes de la matrice (correspondant aux hyper-arˆetes de l’hypergraphe
de repartitionnement) sont remplies une par une. Ce remplissage s’effectue de fa¸con
`a respecter les contraintes sur les sommes des lignes et des colonnes qui correspondent respectivement
aux poids des anciennes parties (w(Pi)) et des nouvelles parties (w(P
′
j
)). La migration
peut ˆetre minimis´ee (optdiag = vrai en entr´ee de l’algorithme) en construisant une hyper-arˆete
de taille 1 pour chaque sommet du graphe quotient quand cela est possible, c’est-`a-dire quand
l’ancienne partie est plus grosse que la nouvelle (w(Pi) > w(P
′
j
)). Les hyper-arˆetes suivantes
sont construites de fa¸con gloutonne en commen¸cant par une sommet pseudo-p´eriph´erique (voir
d´efinition 12) de faible degr´e, puis en ajoutant des sommets v un `a un dans l’hyper-arˆete h en
cherchant `a maximiser un score inspir´e de celui pr´esent´e dans la section 3.3.2 :
score (v, h) =|ES(h) ∩ EV (v)|
|EV (v)|
× |ES(h)| ×
P
e∈ES (h)∩EV (v) we P
e∈EV (v) we
×
X
e∈ES (h)
we
avec
ES(h) = {(u, v) ∈ E : u ∈ h ∧ v ∈ h}
EV (v) = {e ∈ E : v ∈ e} .
(3.17)
ES(h) est l’ensemble des arˆetes du sous-graphe d´efini par l’hyper-arˆete h. EV (v) est l’ensemble des
arˆetes dont une extr´emit´e est v (son voisinage). Le score de l’´equation 3.17 reprend du score 3.16
le produit du nombre d’arˆetes et de leur poids permettant d’obtenir des groupes d’anciennes
parties bien connect´ees et le multiplie par la proportion des arˆetes autour du nouveau sommet
v qui sont dans l’hyper-arˆete h, en nombre et en poids. Cette modification du score permet de
mieux guider l’algorithme glouton qui pr´ef´erera alors choisir des sommets sur le bord ou encercl´es
par l’hyper-arˆete, laissant de meilleurs choix pour la construction des hyper-arˆetes suivantes.
Pour chaque sommet ajout´e dans l’hyper-arˆete, on remplit le coefficient correspondant dans
la matrice avec la valeur maximale permettant de respecter les contraintes de poids sur les lignes
et colonnes. Comme les coefficients de la matrice doivent ˆetre positifs, la somme des valeurs
sur la ligne (et respectivement la colonne) ne doit pas d´epasser la taille d’une partie initiale (et
respectivement finale). A une it´eration de notre algorithme, la valeur choisie pour l’´el´eme ` nt Ci,j50 CHAPITRE 3. MODELE DE MIGRATION `
est donc min(w(Pi) −
P
k Ci,k, w(P
′
j
) −
P
k Ck,j ). Comme on veut obtenir une partition finale
´equilibr´ee, on pose ∀j, w(P
′
j
) = wf inal =
W
N
.
Le volume total de migration peut ˆetre minimis´e en commen¸cant par remplir la diagonale de
la matrice de migration avec les plus grandes valeurs possibles. Le reste de la matrice est alors
rempli normalement selon l’heuristique gloutonne.
Algorithme 2 Construction de la matrice de migration C (Greedy1)
Entr´ee : Nombre d’anciennes parties M
Entr´ee : Nombre de nouvelles parties N
Entr´ee : Graphe quotient de l’ancienne partition Q = (V, E)
Entr´ee : Bool´een optdiag indiquant l’optimisation de la diagonale
C ← matrice nulle de dimension M × N
j ← 0 /* Indice de l’hyper-arˆete en cours de construction. */
/* Construction d’hyper-arˆetes de taille 1. */
si optdiag alors
pour tout v ∈ V correspondant `a l’ancienne partie Pi faire
si wv ≥ wf inal et j < N alors
Ci,j ← wf inal
wv ← wv − wf inal
j ← j + 1
fin si
fin pour
fin si
/* Construction gloutonne des hyper-arˆetes */
tant que j < N faire
v ← sommet pseudo-p´eriph´erique de Q d’indice i et de poids wi non nul
h ← {v} /* Hyper-arˆete d’indice j en cours de construction. */
Ci,j ← min(wi
, wf inal)
wi ← wi − Ci,j
tant que P
k Ck,j < wf inal faire
v ← sommet de V d’indice i, de poids wi non nul tel que score(v, h ∪ {v})
soit maximal
h ← h ∪ {v}
Ci,j ← min(wi
, wf inal −
P
k Ck,j )
wi ← wi − Ci,j
fin tant que
j ← j + 1
fin tant que
retourner C
Notre algorithme se base sur la notion de sommet pseudo-p´eriph´erique pour trouver un sommet
sur le « bord » du graphe. Rechercher un sommet p´eriph´erique 4
est plus complexe et n’est
pas n´ecessaire pour l’application de notre heuristique.
D´efinition 11 (Excentricit´e). L’excentricit´e d’un sommet v dans un graphe, not´ee ǫ(v), est la
plus grande distance entre v et n’importe quel autre sommet du graphe.
4. Un sommet p´eriph´erique est un sommet d’excentricit´e maximale.3.3. CONSTRUCTION DES MATRICES DE MIGRATION 51
D´efinition 12 (Sommet pseudo-p´eriph´erique). Un sommet v est un sommet pseudo-p´eriph´erique
si pour tous les sommets u les plus ´eloign´es de v, on a ǫ(v) = ǫ(u) = d(u, v). Plus formellement
v est pseudo-p´eriph´erique si ∀u ∈ V, d(u, v) = ǫ(v) =⇒ d(u, v) = ǫ(u).
Un sommet pseudo-p´eriph´erique peut ˆetre facilement trouv´e comme le montre l’algorithme 3.
En partant d’un sommet quelconque, on cherche, `a l’aide d’un parcours en largeur, un sommet
le plus loin possible (calculant ainsi l’excentricit´e du sommet de d´epart) et de faible degr´e.
Cette recherche est r´ep´et´ee `a partir du nouveau sommet jusqu’`a trouver un sommet dont l’excentricit´e
est ´egale `a celle du sommet pr´ec´edent. En pratique cet algorithme termine en tr`es peu
d’it´erations [21] (2 ou 3 it´erations lors de nos tests).
Algorithme 3 Recherche d’un sommet pseudo-p´eriph´erique de degr´e faible
Entr´ee : Graphe G
u ← sommet quelconque de G
ǫnouveau ← 0
r´ep´eter
Effectuer un parcours en largeur du graphe G en partant de u
v ← sommet avec une distance maximale et un degr´e minimal
ǫcourant ← ǫnouveau
ǫnouveau ← d(u, v) /* correspond `a l’excentricit´e de u */
u ← v
jusqu’`a ǫnouveau = ǫcourant
retourner u
b) Optimisation du nombre de messages par une recherche de sous-ensembles
L’algorithme 2 construit une matrice de migration avec M + N − 1 messages. A chaque `
it´eration, la valeur de l’´el´ement est choisie pour satisfaire la contrainte de poids sur la ligne ou
la colonne, sauf `a la derni`ere it´eration o`u les contraintes sur la ligne et la colonne de l’´el´ement
sont satisfaites. Comme il y a M lignes et N colonnes, il y a au plus M + N − 1 it´erations et
´el´ements non nuls.
Il est possible de diminuer ce nombre de messages en d´ecomposant le probl`eme de construction
de la matrice de migration en plusieurs sous-probl`emes de repartitionnement sur des sousensembles
disjoints de parties, comme le montre la d´emonstration du lemme 2. Pour d´ecomposer
le probl`eme en K sous-probl`emes, l’ensemble des parties (Pi)i∈J1,MK est partitionn´e en K
sous-ensembles (Sj )j∈J1,KK
. Pour chaque sous ensemble Sj , la somme des poids des parties qu’il
contient est `a peu pr`es un multiple de la taille id´eale d’une partie finale. Plus formellement, avec
un facteur de d´es´equilibre ǫ, un sous-ensemble Sj est de « bonne taille » si il existe un entier Nj
tel que P
j Nj = N et
(1 − ǫ) × Nj
W
N
<
X
Pi∈Sj
w(Pi) < (1 + ǫ) × Nj
W
N
.
On note Mj = |Sj | la taille de chaque sous-ensemble. Comme les sous-ensembles sont une partition
de l’ensemble des parties, on a P
j Mj = M. Chaque sous probl`eme est donc de taille
Mj × Nj et construit une sous-matrice de migration avec Mj + Nj − 1 messages. Le nombre
de messages total est donc M + N − K. Pour minimiser le nombre de messages, il faut donc
trouver le plus possible de sous-ensembles. Dans le cas ´equilibr´e, on trouvait pgcd(M, N) tels
sous-ensembles de chacun M/pgcd(M, N) parties.52 CHAPITRE 3. MODELE DE MIGRATION `
La recherche de tels sous-ensembles est une version plus g´en´erale du probl`eme de la somme
d’un sous-ensemble 5 qui est NP-complet [20, SUBSET SUM]. Ces sous-ensembles peuvent ˆetre
construits avec un algorithme glouton similaire `a celui de construction de la matrice de migration.
Dans l’algorithme 4, on commence par trouver un sommet pseudo-p´eriph´erique dans le graphe
quotient, puis on cherche parmi ses voisins si il existe un sommet permettant de cr´eer un sousensemble
de la bonne taille, sinon on en choisit un qui maximise le score du sous-ensemble comme
dans l’algorithme 2. Puis on recommence `a chercher parmi les voisins du sous-ensemble jusqu’`a
construire un sous-ensemble de bonne taille. Au pire, l’algorithme termine en s´electionnant tous
les sommets du graphe quotient dans un seul sous-ensemble, puisque par d´efinition de la taille
id´eale, le poids total du graphe vaut N fois celle-ci.
Algorithme 4 Construction de la matrice de migration avec une recherche de sous-ensembles
(Greedy2)
Entr´ee : Nombre d’anciennes parties M
Entr´ee : Nombre de nouvelles parties N
Entr´ee : Graphe quotient Q = (V, E)
R ← V /* Ensemble des sommets restants */
tant que R 6= ∅ faire
u ← un sommet pseudo-p´eriph´erique du sous-graphe de Q restreint `a R
S ← {u}
R ← R \ {u}
tant que S n’est pas un sous-ensemble de bonne taille pour N′ nouvelles parties faire
si il existe v ∈ R tel que v est connect´e `a S et S ∪ {v} est de bonne taille alors
S ← S ∪ {v} /* S´electionner v */
R ← R \ {v}
sinon
u ← sommet maximisant le score du sous-ensemble S ∪ {u}
S ← S ∪ {u} /* S´electionner u */
R ← R \ {u}
fin si
fin tant que
Construire la sous-matrice |S| × N′ associ´ee au sous-ensemble S (appel de l’algorithme 2
(Greedy1) sur le sous-graphe de Q restreint `a S)
fin tant que
Un exemple d’application de ces algorithmes est pr´esent´e sur les figures 3.23 `a 3.25 avec
le cas 5 × 7 d´es´equilibr´e. La figure 3.23 pr´esente la recherche des sous-ensembles, alors que les
figures 3.24 et 3.25 pr´esentent respectivement les constructions des sous-matrices pour chacun
des sous-ensembles. Les poids des parties initiales sont dans l’ordre 500, 900, 2400, 1500 et
1700. Les parties finales devront ˆetre de poids 1000. Les valeurs indiqu´ees `a cot´e des sommets
correspondent aux donn´ees des anciennes parties qui n’ont pas encore ´et´e affect´ees dans une
nouvelle. Les ´el´ements de la matrice ne faisant pas partie de la sous-matrice concern´ee sont
gris´es.
L’algorithme commence par chercher un sous-ensemble en partant d’un sommet pseudop´eriph´erique
(figure 3.23a). Parmi les voisins, la partie 3 permet d’avoir un sous-ensemble adapt´e
5. Etant donn´e un ensemble d’entiers, existe-t-il un sous-en ´ semble non vide dont la somme vaut une valeur
donn´ee ?3.3. CONSTRUCTION DES MATRICES DE MIGRATION 53
39
39
14
34
17
62
65
500
1 900
2 2400
3 1500
4 1700
(a) Premi`ere ´etape de
la construction des sousensembles.
39
39
14
34
17
62
65
500
1 900
2 2400
4 1700
(b) Seconde ´etape de la
construction des sousensembles
: le premier
sous-ensemble est termin´e.
39
39
14
34
17
62
65
500
900
(c) Cinqui`eme et derni`ere ´etape
de la construction des sousensembles.
Figure 3.23 – Construction des sous-ensembles.
au repartitionnement en 2 parties (500+1500 = 2×1000) (figure 3.23b). L’algorithme de construction
de la matrice de migration est alors appliqu´e sur le sous-ensemble {0, 3}. La partie 0 est trop
petite pour cr´eer une hyper-arˆete de taille 1 (figure 3.24a). La partie 3 a un poids suffisant donc
1000 est ajout´e sur la diagonale (figure 3.24b). Il reste alors une hyper-arˆete `a construire : elle
part du sommet 0 (figure 3.24c) et s’´etend sur le seul sommet voisin 3 (figure 3.24d). Les deux
hyper-arˆetes n´ecessaires sont donc construites et toutes les donn´ees de 0 et 3 ont ´et´e redistribu´ees.
Le second sous-ensemble est construit avec le reste du graphe quotient (figure 3.23c). Les
parties 1, 2 et 4 seront repartitionn´ees vers 5 parties (900 + 2400 + 1700 = 5 × 1000). On commence
par construire les hyper-arˆetes de taille 1 (figure 3.25a) pour optimiser la diagonale de
la matrice, ici 2 et 4 sont de poids suffisants. L’hyper-arˆete suivante est construite `a partir de 1
(figure 3.25b) et s’´etend sur le voisin « libre » le plus connect´e `a 1 : 2 (figure 3.25c). La suivante
est construite `a partir de 2 qui a encore assez de donn´ees (1300) pour construire une hyper-arˆete
de taille 1 (figure 3.25d). La derni`ere hyper-arˆete part de 2 (figure 3.25e) et s’´etend sur le seul
sommet restant, la partie 4 (figure 3.25f).
Par la suite, nous utiliserons syst´ematiquement la recherche des sous-ensembles (Greedy2)
pour notre algorithme glouton (Greedy).
c) Illustration de la m´ethode gloutonne
Les figures 3.26 et 3.27 pr´esentent des r´esultats de la m´ethode gloutonne avec optimisation de
la diagonale dans les cas ´equilibr´es et d´es´equilibr´es. Comme avec la m´ethode d’appariement, de
grandes hyper-arˆetes sont cr´e´ees. Cela est dˆu au remplissage de la diagonale qui laisse de petits
restes pour cr´eer les parties suppl´ementaires. Dans le cas d´es´equilibr´e, cet effet est att´enu´e : la
diagonale ne peut pas toujours ˆetre remplie et les restes peuvent ˆetre plus importants.
Les figures 3.28 et 3.29 montrent les r´esultats dans les mˆemes cas, mais sans l’optimisation
de la diagonale. Les tailles des hyper-arˆetes sont bien plus raisonnables. Comme avec la m´ethode
de la chaˆıne, les nouvelles parties sont souvent plac´ees entre deux anciennes parties voisines.54 CHAPITRE 3. MODELE DE MIGRATION `
39
39
14
34
17
62
65
0 500
1 0
2 0
3 1500
4 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
(a) Premi`ere ´etape du remplissage de la diagonale.
39
39
14
34
17
62
65
0 500
1 0
2 0
500
4 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 1000 0 0 0
0 0 0 0 0 0 0
(b) Seconde ´etape du remplissage de la diagonale.
39
39
14
34
17
62
65
0
1 0
2 0
500
4 0
500 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 1000 0 0 0
0 0 0 0 0 0 0
(c) Premi`ere ´etape de la construction de la seconde
hyper-arˆete.
39
39
14
34
17
62
65
0
1 0
2 0
4 0
500 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
500 0 0 1000 0 0 0
0 0 0 0 0 0 0
(d) L’hyper-arˆete est construite.
Figure 3.24 – Construction des sous-ensembles et de la sous-matrice correspondant au premier
sous-ensemble {0, 3}.3.3. CONSTRUCTION DES MATRICES DE MIGRATION 55
39
39
14
34
17
62
65
1 900
1400
700
500 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 1000 0 0 0 0
500 0 0 1000 0 0 0
0 0 0 0 1000 0 0
(a) Remplissage de la diagonale.
39
39
14
34
17
62
65
1400
700
500 0 0 0 0 0 0
0 900 0 0 0 0 0
0 0 1000 0 0 0 0
500 0 0 1000 0 0 0
0 0 0 0 1000 0 0
(b) Premi`ere ´etape de la construction de la troisi`eme
hyper-arˆete.
39
39
14
34
17
62
65
700
500 0 0 0 0 0 0
0 900 0 0 0 0 0
0 100 1000 0 0 0 0
500 0 0 1000 0 0 0
0 0 0 0 1000 0 0
(c) Seconde ´etape de la construction de la troisi`eme
hyper-arˆete.
39
39
14
34
17
62
65
700
500 0 0 0 0 0 0
0 900 0 0 0 0 0
0 100 1000 0 0 1000 0
500 0 0 1000 0 0 0
0 0 0 0 1000 0 0
(d) Construction de la quatri`eme hyper-arˆete.
39
39
14
34
17
62
65
700
500 0 0 0 0 0 0
0 900 0 0 0 0 0
0 100 1000 0 0 1000 300
500 0 0 1000 0 0 0
0 0 0 0 1000 0 0
(e) Premi`ere ´etape de la construction de la cinqui`eme
hyper-arˆete.
39
39
14
34
17
62
65
500 0 0 0 0 0 0
0 900 0 0 0 0 0
0 100 1000 0 0 1000 300
500 0 0 1000 0 0 0
0 0 0 0 1000 0 700
(f) Seconde ´etape de la construction de la cinqui`eme
hyper-arˆete et fin de l’algorithme.
Figure 3.25 – Construction de la sous-matrice correspondant au second sous-ensemble {1, 2, 4}.56 CHAPITRE 3. MODELE DE MIGRATION `
52
22
49
5
26
47
6
50
51
8
24
22
51
(a) Hypergraphe de repartitionnement
dans le cas 8 × 12
´equilibr´e.
26 21
17
32
26 23
30
12
28
27
40
30
3
9
29
19
22
21
25
21
17
29
29
(b) Hypergraphe de repartitionnement
dans le cas 12 × 14
´equilibr´e.
27
20
24 4
23
4
5
30 23
21
5
25
21
25
8
21
21
4
25
29
26
10 24
8 26
23
20
28
4 23
23
24
23
(c) Hypergraphe de repartitionnement
dans le cas 16×21 ´equilibr´e.
Figure 3.26 – Evaluation du repartitionnement `a l’aide de l’algorithme glouton avec op ´ timisation
de la diagonale dans des cas ´equilibr´es.
52
22
49
5
26
47
6
50
51
8
24
22
51
(a) Hypergraphe de repartitionnement
dans le cas 8 × 12
d´es´equilibr´e.
26 21
17
32
26 23
30
12
28
27
40
30
3
9
29
19
22
21
25
21
17
29
29
(b) Hypergraphe de repartitionnement
dans le cas 12 × 14
d´es´equilibr´e.
27
20
24 4
23
4
5
30 23
21
5
25
21
25
8
21
21
4
25
29
26
10 24
8 26
23
20
28
4 23
23
24
23
(c) Hypergraphe de repartitionnement
dans le cas 16 × 21 d´es-
´equilibr´e.
Figure 3.27 – Evaluation du repartitionnement `a l’aide de l’algorithme glouton avec op ´ timisation
de la diagonale dans des cas d´es´equilibr´es.3.3. CONSTRUCTION DES MATRICES DE MIGRATION 57
52
22
49
5
26
47
6
50
51
8
24
22
51
(a) Hypergraphe de repartitionnement
dans le cas 8 × 12
´equilibr´e.
26 21
17
32
26 23
30
12
28
27
40
30
3
9
29
19
22
21
25
21
17
29
29
(b) Hypergraphe de repartitionnement
dans le cas 12 × 14
´equilibr´e.
27
20
24 4
23
4
5
30 23
21
5
25
21
25
8
21
21
4
25
29
26
10 24
8 26
23
20
28
4 23
23
24
23
(c) Hypergraphe de repartitionnement
dans le cas 16×21 ´equilibr´e.
Figure 3.28 – Evaluation du repartitionnement `a l’aide de l’algorithme glouton sans opt ´ imisation
de la diagonale dans des cas ´equilibr´es.
52
22
49
5
26
47
6
50
51
8
24
22
51
(a) Hypergraphe de repartitionnement
dans le cas 8 × 12
d´es´equilibr´e.
26 21
17
32
26 23
30
12
28
27
40
30
3
9
29
19
22
21
25
21
17
29
29
(b) Hypergraphe de repartitionnement
dans le cas 12 × 14
d´es´equilibr´e.
27
20
24 4
23
4
5
30 23
21
5
25
21
25
8
21
21
4
25
29
26
10 24
8 26
23
20
28
4 23
23
24
23
(c) Hypergraphe de repartitionnement
dans le cas 16 × 21 d´es-
´equilibr´e.
Figure 3.29 – Evaluation du repartitionnement `a l’aide de l’algorithme glouton sans opt ´ imisation
de la diagonale dans des cas d´es´equilibr´es.58 CHAPITRE 3. MODELE DE MIGRATION `
3.3.4 Programme lin´eaire (LP)
Les m´ethodes de repartitionnement diffusives [26,46] optimisent le volume de migration en effectuant
des communications entre les parties voisines sur le graphe quotient (cf. section 2.3.2 b)).
Nous proposons d’´etendre la m´ethode en utilisant un programme lin´eaire dans le cas du repartitionnement
avec changement dynamique du nombre de processeurs et pour optimiser les
diff´erentes m´etriques TotalV, MaxV, TotalZ et MaxZ.
Le principal probl`eme de cette adaptation est que le graphe quotient ne prend en compte que
les anciennes parties et non les nouvelles. Il faut donc adapter celui-ci pour prendre en compte ce
changement de nombre de parties. Pour un repartitionnement de M vers N parties, on utilise un
graphe d´ecrivant les messages possibles entre max(M, N) parties. Le poids de certaines parties
peut ˆetre initialement nul, si elles n’existaient pas dans l’ancienne partition (cas o`u M < N) ; on
peut aussi vouloir un poids final nul pour les parties qui n’existent pas dans la nouvelle partition
(cas o`u M > N).
Dans le cas o`u le nombre de parties augmente (M < N), il faut ajouter des nouveaux
sommets dans le graphe quotient et, pour que la migration soit possible, connecter ces nouveaux
sommets avec le reste du graphe. En effet, Hu et al. [26] montrent que pour qu’une solution soit
possible, le graphe doit ˆetre connexe. On veut donc construire `a partir du graphe quotient Q, un
nouveau graphe quotient enrichi Q˜. La fa¸con dont sont connect´es ces nouveaux sommets influence
grandement la migration optimale possible, mais aussi la coupe de la partition finale. Pour obtenir
une bonne migration, il faut placer les nouvelles parties proches des anciennes parties capables
de fournir les sommets n´ecessaires. Pour obtenir une bonne coupe, il faut connecter les nouvelles
parties avec des anciennes proches entre elles. Une m´ethode na¨ıve pour trouver de tels placements
est de rechercher dans le graphe quotient de petites cliques de parties bien connect´ees entre elles
et poss´edant un poids ´elev´e.
Dans le cas o`u le nombre de parties diminue, le graphe quotient n’a pas besoin d’ˆetre modifi´e
mais il faut choisir les parties qui seront supprim´ees, c’est-`a-dire dont le poids final vis´e est nul.
a) Optimisation du volume total de migration TotalV
Une fois le graphe Q˜ des messages autoris´es construit, il faut d´ecider du volume de donn´ees
`a communiquer sur chaque arˆete. Pour minimiser le volume total de migration, il est possible
d’utiliser le programme lin´eaire suivant :
minimiser X
i,j
eij
. Contraintes lin´eaires :
∀i ∈ V, vi =
X
j
(eji − eij ). (3.18)
Bornes :
∀i ∈ V, vi ≤ di + ub. (3.19)
∀(i, j) ∈ E, 0 ≤ eij . (3.20)
On note eij la quantit´e de donn´ees envoy´ees par la partie i vers la partie j. Cette variable
est toujours positive ou nulle (´equation 3.20) ; si le message se passe dans l’autre sens, eij est
nul et eji contient le volume de donn´ees ´echang´ees. vi est la variation de la quantit´e de donn´ees
de la partie i et est ´egale `a la diff´erence des donn´ees re¸cues et envoy´ees (´equation 3.18). di est3.3. CONSTRUCTION DES MATRICES DE MIGRATION 59
1
2
3
1
3
2
4
4 3
5
2
3 3
0
Figure 3.30 – Exemple de partition initiale et de son graphe quotient enrichi.
la variation souhait´ee de la quantit´e de donn´ees de la partie i, c’est-`a-dire la diff´erence entre le
poids initial et le poids souhait´e. vi doit ˆetre `a peu pr`es ´egal `a di `a une tol´erance de d´es´equilibre
ub pr`es (´equation 3.19).
Par exemple, en prenant la partition en trois parties de la figure 3.30, on construit un graphe
quotient de trois sommets auquel on ajoute un quatri`eme pour repartitionner en 4 parties. Ici,
le nouveau sommet est connect´e aux trois autres.
L’application des contraintes 3.18 donne :
v1 = e21 − e12 + e31 − e13 + e41 − e14
v2 = e12 − e21 + e21 − e23 + e42 − e24
v3 = e13 − e31 + e23 − e32 + e43 − e34
v4 = e14 − e41 + e24 − e42 + e34 − e43
et les bornes 3.19 :
v1 ≤ −1
v2 ≤ 0
v3 ≤ −2
v4 ≤ 3.
De plus tous les eij sont positifs ou nuls. La solution de ce probl`eme est :
e41 = 1
e43 = 2
et tous les autres eij sont nuls. Ce qui veut dire que la partie 1 devra envoyer un sommet `a la
partie 4 et la partie 3 devra en envoyer deux. Il n’y a pas d’autre communication.
b) Extension `a d’autres m´etriques
Il est possible d’´etendre le programme lin´eaire pour d’autres objectifs, tels que : MaxV,
TotalZ, MaxZ ou n’importe quelle combinaison lin´eaire de ceux-ci.
Pour optimiser MaxV, il suffit d’ajouter une variable v repr´esentant le volume maximal de
migration par partie. On cherche donc `a minimiser v = maxi∈V
P
j
(eij + eji)
. Cela se traduit
par les contraintes suppl´ementaires :60 CHAPITRE 3. MODELE DE MIGRATION `
39
39
14
34
17 62
65 0 2020
1 1984
2 1986
3 2014
4 1996
(a) Graphe quotient.
39
39
14
34
17
62
65
(b) Groupes de sommets retenus
pour les nouvelles parties
ajout´ees.
0
1
2
3
4
5
6
(c) Graphe quotient enrichi
avec les nouveaux sommets.
1500 0 0 0 0 520 0
0 1184 0 0 0 0 800
0 0 1428 0 0 0 558
0 0 0 1500 0 514 0
0 172 0 0 1500 324 0
(d) Matrice de migration obtenue pour l’optimisation de TotalV.
Figure 3.31 – Enrichissement du graphe quotient puis construction de la matrice de migration
pour le cas 5 × 7.
∀i ∈ V,X
j
(eij + eji) ≤ v. (3.21)
v ´etant minimis´e, il vaut bien la plus grande des valeurs P
j
(eij + eji).
Lorsque les valeurs eij sont enti`eres, on peut ajouter des variables binaires xij pour chaque
arˆete donnant l’existence ou non d’un message sur cette arˆete grˆace aux contraintes :
xij ≤ eij ≤ W xij . (3.22)
W est le poids total du graphe, aucun message ne peut d´epasser cette taille. En ´etudiant les deux
cas possibles suivant la valeur de xij , on obtient :
eij = 0 si xij = 0
1 ≤ eij ≤ W si xij = 1.
(3.23)
xij correspond donc bien `a l’existence d’un message de la partie i vers la partie j. Il est alors
possible de minimiser TotalZ en minimisant la somme des xij et MaxZ en utilisant une m´ethode
similaire `a celle pour MaxV.
Les programmes lin´eaires complets pour les diff´erentes m´etriques sont d´ecrits dans l’annexe A.
c) Application du programme lin´eaire
Pour enrichir le graphe quotient, un algorithme recherche, pour chaque nouvelle partie suppl´ementaire,
de petits groupes de sommets (de taille 1, 2 ou 3) bien connect´es et de poids importants.3.3. CONSTRUCTION DES MATRICES DE MIGRATION 61
52
22
49
5
26
47
6
50
51
8
24
22
51
(a) Hypergraphe de repartitionnement
dans le cas 8 × 12
´equilibr´e.
26 21
17
32
26 23
30
12
28
27
40
30
3
9
29
19
22
21
25
21
17
29
29
(b) Hypergraphe de repartitionnement
dans le cas 12 × 14
´equilibr´e.
27
20
24 4
23
4
5
30 23
21
5
25
21
25
8
21
21
4
25
29
26
10 24
8 26
23
20
28
4 23
23
24
23
(c) Hypergraphe de repartitionnement
dans le cas 16×21 ´equilibr´e.
Figure 3.32 – Application de la construction de la matrice de migration `a l’aide du programme
lin´eaire dans des cas ´equilibr´es.
Nous ne d´etaillerons pas ici cet algorithme qui utilise une approche gloutonne selon un crit`ere
comparable `a celui de la m´ethode Greedy, mais en bornant la taille des hyper-arˆetes (entre 1 et
3). Sur l’exemple de la figure 3.31, pour passer de 5 `a 7 parties, il faut ajouter deux nouvelles
parties : un groupe de trois sommets et un groupe de deux sont choisis (fig. 3.31b). Les deux
nouveaux sommets sont connect´es aux anciens sommets d’apr`es ces ensembles (fig. 3.31c). En
appliquant le programme lin´eaire pour l’optimisation de TotalV sur ce graphe quotient enrichi,
on obtient 6 messages : 5 messages correspondant aux arˆetes ajout´ees pour cr´eer les nouvelles
parties suppl´ementaires et un message entre les parties 4 et 1. Pr´esent´es sous forme de matrice
de migration, ces r´esultats donnent la matrice sur la figure 3.31d. Les valeurs sur la diagonale (en
gris) ne sont pas obtenues directement par le programme lin´eaire mais calcul´ees indirectement
d’apr`es les tailles des messages et les tailles des anciennes parties.
52
22
49
5
26
47
6
50
51
8
24
22
51
(a) Hypergraphe de repartitionnement
dans le cas 8 × 12
d´es´equilibr´e.
26 21
17
32
26 23
30
12
28
27
40
30
3
9
29
19
22
21
25
21
17
29
29
(b) Hypergraphe de repartitionnement
dans le cas 12 × 14
d´es´equilibr´e.
27
20
24 4
23
4
5
30 23
21
5
25
21
25
8
21
21
4
25
29
26
10 24
8 26
23
20
28
4 23
23
24
23
(c) Hypergraphe de repartitionnement
dans le cas 16 × 21 d´es-
´equilibr´e.
Figure 3.33 – Application de la construction de la matrice de migration `a l’aide du programme
lin´eaire dans des cas d´es´equilibr´es.
Les r´esultats obtenus pour diff´erents cas avec l’optimisation de TotalV sont pr´esent´es sur62 CHAPITRE 3. MODELE DE MIGRATION `
les figures 3.32 et 3.33. Les tailles des hyper-arˆetes finales correspondant aux nouvelles parties
sont effectivement limit´ees `a un maximum de 3 et les autres communications se font uniquement
le long des arˆetes du graphe quotient.
Cet algorithme optimise la m´etrique souhait´ee, mais relativement `a un graphe quotient enrichi
donn´e dont la construction ne permet pas toujours une migration optimale.
3.4 Evaluation des m´ethodes et conclusion ´
Nous comparons les m´ethodes de construction de matrice de migration pr´esent´ees dans ce
chapitre : la m´ethode bas´ee sur la chaˆıne (1D), la m´ethode d’appariement (Matching, seulement
dans le cas ´equilibr´e), les deux variantes de l’algorithme glouton avec optimisation de la diagonale
(GreedyD) et sans (Greedy) et le programme lin´eaire optimisant TotalV (LP).
Les m´ethodes pr´esent´ees sont ´evalu´ees sur six cas ´equilibr´es et d´es´equilibr´es. Les trois cas
´equilibr´es sont :
— 8×12 avec des anciennes parties de taille 1500 et donc des nouvelles parties de taille 1000 ;
— 12 × 14 avec des anciennes parties de taille 1000 et donc des nouvelles parties de taille
857 ;
— 16 × 21 avec des anciennes parties de taille 1000 et donc des nouvelles parties de taille
761.
Les trois cas d´es´equilibr´es utilisent les mˆemes nombres de parties :
— 8 × 12 avec un d´es´equilibre de 49 % et des nouvelles parties de taille 1509 ;
— 12 × 14 avec un d´es´equilibre de 58 % et des nouvelles parties de taille 1311 ;
— 16 × 21 avec un d´es´equilibre de 50 % et des nouvelles parties de taille 922.
Ces d´es´equilibres ont ´et´e r´ealis´es avec la m´ethode utilis´ee par l’article [56] : pour chaque partie,
un nombre al´eatoire de sommets sont s´electionn´es pour avoir leur poids tripl´es, conduisant `a un
d´es´equilibre d’environ 50 %.
Les tableaux 3.1 et 3.2 pr´esentent les m´etriques associ´ees aux applications pr´esent´ees dans
les sections pr´ec´edentes. Les quatre m´etriques pr´esent´ees ne permettent pas d’´evaluer la qualit´e
de la coupe finale mais seulement la qualit´e de la migration. La coupe ne pourra ˆetre ´evalu´ee
qu’apr`es le repartitionnement dans le chapitre 5.
En dehors du repartitionnement 8×12 dans le cas ´equilibr´e, on remarque que les optimisations
de TotalV et MaxZ sont contradictoires. En effet, comme expliqu´e avec la m´ethode d’appariement,
l’optimisation de la diagonale oblige les nouvelles parties suppl´ementaires `a prendre
les donn´ees depuis de nombreuses anciennes parties, ce qui favorise des hyper-arˆetes de grandes
tailles et donc l’augmentation de MaxZ. Les m´ethodes 1D et Greedy donnent un MaxZ bas
mais un TotalV plus ´elev´e, contrairement aux m´ethodes Matching (avec choix d’une matrice
diagonale) et GreedyD qui optimisent en priorit´e TotalV. Le cas du programme lin´eaire est
particulier : bien que le programme lin´eaire minimise TotalV, la construction du graphe quotient
enrichi impose un degr´e faible. Malgr´e cette minimisation, TotalV peut ˆetre plus ´elev´e
qu’avec d’autres m´ethodes mais MaxZ est maintenu bas. TotalV aurait pu ˆetre plus bas avec
un choix de graphe quotient enrichi diff´erent. Il est ´egalement possible d’utiliser le programme
lin´eaire pour optimiser d’autres crit`eres.
Dans le cas 8 × 12 ´equilibr´e, il existe une solution donnant `a la fois un TotalV bas et un
MaxZ bas que toutes les m´ethodes trouvent. Le programme lin´eaire est capable de donner un
TotalV plus bas que l’optimal (4000) en profitant de la tol´erance au d´es´equilibre.
Le MaxV varie peu d’une m´ethode `a l’autre et il est g´en´eralement proche de la taille d’une
nouvelle partie. Une nouvelle partie devant recevoir l’int´egralit´e de ses donn´ees, il n’est pas3.4. EVALUATION DES M ´ ETHODES ET CONCLUSION ´ 63
possible d’avoir un MaxV inf´erieur `a la taille id´eale d’une nouvelle partie.
Dans le cas ´equilibr´e, le TotalZ optimal est bien atteint pour toutes les m´ethodes sauf le
programme lin´eaire qui n’optimise pas ce crit`ere. Dans le cas d´es´equilibr´e, l’optimal n’est pas
connu. La m´ethode de la chaˆıne atteint max(M, N) − 1 messages et les algorithmes gloutons
donne un nombre de messages inf´erieur grˆace `a la recherche des sous-ensembles. Bien que le
programme lin´eaire n’optimise pas le nombre de messages, celui-ci reste tr`es bas. C’est un effet
de bord de la minimisation de TotalV.
Dans la suite de cette th`ese, nous retiendrons les m´ethodes utilisant l’algorithme glouton
(Greedy et GreedyD) et le programme lin´eaire (LP). L’algorithme glouton permet de minimiser
TotalZ et offre deux variantes permettant au choix de minimiser fortement TotalV ou de
garder MaxZ bas. La m´ethode d’appariement (Matching) n’est pas utilisable dans le cas g´en´eral
et la m´ethode 1D donne des r´esultats comparables `a la m´ethode Greedy (MaxZ faible mais
TotalV plus ´elev´e) mais avec de moins bons r´esultats.
La construction de matrices de migration `a partir du graphe quotient est la premi`ere ´etape
de notre m´ethode de repartitionnement dont la d´emarche globale est rappel´ee en figure 3.34. Les
matrices de migration ainsi construites vont ˆetre utilis´ees par les algorithmes de repartitionnement
de graphe pr´esent´es dans le chapitre suivant.64 CHAPITRE 3. MOD
`ELE DE MIGRATION
1D (fig. 3.14) Matching
(fig. 3.22)
GreedyD
(fig. 3.26)
Greedy
(fig. 3.28)
LP (fig. 3.32)
Cas 8 × 12
TotalV 4000 4000 4000 4000 3960
MaxV 1000 1000 1000 1000 900
TotalZ 8 8 8 8 8
MaxZ 2 2 2 2 2
Cas 12 × 14
TotalV 3427 1714 1714 3426 2900
MaxV 857 857 857 857 939
TotalZ 12 12 12 12 13
MaxZ 2 6 6 2 3
Cas 16 × 21
TotalV 5239 3808 3808 5335 5606
MaxV 762 762 762 762 1150
TotalZ 20 20 20 20 20
MaxZ 2 4 4 3 3
Table 3.1 – R´esultats des diff´erentes m´ethodes dans le cas ´equilibr´e.3.4. EVALUATION DES M ´ ETHODES ET CONCLUSION ´ 65 1D (fig. 3.16) GreedyD (fig. 3.27) Greedy (fig. 3.29) LP (fig. 3.33) Cas 8 × 12 TotalV 7453 6266 7127 6299 MaxV 1871 1869 1869 1862 TotalZ 11 10 10 10 MaxZ 2 4 3 2 Cas 12 × 14 TotalV 5064 5960 5769 5261 MaxV 1311 1372 1372 2013 TotalZ 13 12 12 13 MaxZ 2 3 3 4 Cas 16 × 21 TotalV 6200 5504 6138 5858 MaxV 922 922 923 1103 TotalZ 20 18 18 19 MaxZ 2 5 3 4 Table 3.2 – R´esultats des diff´erentes m´ethodes dans le cas d´es´equilibr´e.66 CHAPITRE 3. MOD
`ELE DE MIGRATION Méthode d'appariement (Matching) Méthode de la chaîne (1D)
Méthode gloutonne (Greedy)
Méthode de partitionnement biaisé (Biased)
Méthode diffusive (Diff)
Hyper-arêtes de repartitionnement
Matrice de
migration
Graphe
quotient
Nouvelle
partition
en N
Graphe
partitionné
en M
Construction de la matrice de migration M×N
Repartitionnement M×N
Programme linéaire (LP)
Figure 3.34 – Vue d’ensemble.Chapitre 4
Repartitionnement M × N
Sommaire
4.1 Repartitionnement M×N bas´e sur le partitionnement biais´e (BIASED)
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
4.1.1 M´ethodologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
4.1.2 Limitations des partitionneurs . . . . . . . . . . . . . . . . . . . . . . 71
4.2 Partitionnement k-aire direct (KGGGP) . . . . . . . . . . . . . . . 73
4.2.1 Description de l’algorithme . . . . . . . . . . . . . . . . . . . . . . . . 73
4.2.2 Crit`eres de s´election . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.2.3 Complexit´e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
4.2.4 Am´eliorations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
4.2.5 Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 ´
4.3 Repartitionnement M × N bas´e sur la diffusion (DIFF) . . . . . . . 85
4.4 Partitionnement biais´e `a l’aide d’hyper-arˆetes de repartitionnement 89
4.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Dans ce chapitre, nous pr´esentons nos algorithmes de repartitionnement M × N, r´esum´es en
figure 4.1. Nos m´ethodes de repartitionnement biais´e (BIASED) et diffusive (DIFF) s’inspirent
des m´ethodes de repartitionnement classiques du mˆemes noms mais sont ´etendues dans le cas
du repartitionnement avec un nombre de processeurs variable. Ces deux m´ethodes se basent
sur une matrice de migration obtenue `a l’aide d’un des algorithmes pr´esent´es dans le chapitre
pr´ec´edent. De plus, dans le cadre de notre partitionnement biais´e, nous mettons en ´evidence des
limitations de la m´ethode des bissections r´ecursives largement utilis´ee par les diff´erents outils
de partitionnement actuels, et nous proposons une m´ethode de partitionnement k-aire direct
(KGGGP) qui surmonte ces limitations.
4.1 Repartitionnement M × N bas´e sur une m´ethode de
partitionnement biais´e (BIASED)
Nous pr´esentons dans cette section une m´ethode partitionnement biais´e permettant de r´ealiser
un repartitionnement M × N en respectant un mod`ele de migration donn´e par une matrice C.
Cette m´ethode n’impose que les messages donn´es dans le mod`ele de migration et non leur volume.
N´eanmoins, les volumes sont respect´es lorsque le nombre de messages de C est minimal, comme
6768 CHAPITRE 4. REPARTITIONNEMENT M × N
Méthode de partitionnement biaisé (Biased)
Méthode diffusive (Diff)
Hyperarêtes de repartitionnement
Matrice de
migration
Nouvelle
partition
en N
Graphe
partitionné
en M
Repartitionnement M×N
Figure 4.1 – Vue d’ensemble de nos algorithmes de repartitionnement M × N d’un graphe.
nous le verrons dans la section suivante. Cette m´ethode est donc d´econseill´ee pour les mod`eles de
migration n’optimisant pas TotalZ, en particulier ceux obtenus `a l’aide du programme lin´eaire
optimisant seulement TotalV, MaxV ou MaxZ.
Cette m´ethode de partitionnement biais´e s’inspire des m´ethodes de repartitionnement utilisant
des sommets fixes [2, 8, 9] (cf. section 2.3.2). Le graphe est enrichi avec des sommets fixes et
de nouvelles arˆetes puis il est partitionn´e avec un partitionneur acceptant les sommets fixes.
4.1.1 M´ethodologie
Pour cr´eer un nouvelle partition respectant le mod`ele de communication construit grˆace aux
m´ethodes pr´esent´ees dans le chapitre 3, on utilise une m´ethode de repartitionnement `a sommet
fixes. De la mˆeme fa¸con que dans le cas du repartitionnement sans changement du nombre de
processeurs, on ajoute N sommets fixes de poids nuls repr´esentant les processeurs. Mais au lieu
de les connecter aux sommets de leur ancienne partie, ils sont connect´es aux sommets des parties
dont on accepte qu’ils re¸coivent des donn´ees, conform´ement `a la matrice C.
Plus pr´ecis´ement, pour repartitionner un graphe G de M parties vers N et obtenir une nouvelle
partition P
′
, ´etant donn´e une ancienne partition P = (Pi)i∈J1,MK et une matrice de migration
C, il faut :
1. construire un graphe enrichi G˜ = (V , ˜ E˜) `a partir de G avec :
— N sommets fixes (fj )j∈J1,NK de poids nuls, chacun fix´e dans une nouvelle partie diff´erente
j ;
— des arˆetes suppl´ementaires dont le poids est appel´e « coˆut de migration », telles que
pour chaque ´el´ement Ci,j > 0 de la matrice de migration, les sommets de l’ancienne
partie i soient connect´es au sommet fixe de la nouvelle partie j. Plus formellement,
∀i ∈ J1, MK, ∀j ∈ J1, NK, ∀v ∈ Pi
,
Ci,j 6= 0 ⇐⇒ (v, fj ) ∈ E˜
.
2. partitionner le nouveau graphe enrichi G˜ en N parties avec un partitionneur acceptant
les sommets fixes ;4.1. PARTITIONNEMENT BIAISE´ 69
3. restreindre la partition de G˜ au graphe original G pour obtenir P
′
.
Le rˆole des arˆetes ajout´ees, dites « de migration », n’est pas exactement le mˆeme que dans
les m´ethodes classiques. Elles ne servent pas, ici, `a minimiser la migration directement mais `a
imposer le sch´ema de communication choisi. Un sommet est souvent reli´e `a plusieurs sommets
fixes et au plus une de ses arˆetes de migration peut ne pas ˆetre coup´ee. Avec un poids suffisamment
´elev´e, le partitionneur laissera exactement une arˆete de migration par sommet non-coup´ee, pour
minimiser la coupe. Ainsi, en cherchant `a remplir ses objectifs habituels, le partitionneur impose
le sch´ema de migration choisi.
Un exemple de repartitionnement est propos´e en figure 4.2. En partant de l’ancienne partition
en M = 5 parties (figure 4.2a), on veut construire une nouvelle partition en N = 7 parties. A l’aide `
du graphe quotient associ´e (figure 4.2b), on construit une matrice de migration (ici repr´esent´ee
par l’hypergraphe de repartitionnement) comme indiqu´e dans le chapitre pr´ec´edent (figure 4.2c).
Les arˆetes de migration sont ajout´ees d’apr`es cet hypergraphe sur la figure 4.2d : par exemple,
le sommet fixe de la nouvelle partie 3 est reli´e `a tous les sommets des parties contenues dans
l’hyper-arˆete correspondante (les anciennes parties 3 et 4). Le partitionneur calcule ensuite une
nouvelle partition de ce graphe enrichi. La figure 4.2e montre les arˆetes de migration coup´ees
(en rouge) et internes (en vert). Enfin, la partition de G˜ est restreinte graphe G pour obtenir la
partition finale (figure 4.2f).
Cette m´ethode utilise n’importe quel outil de partitionnement classique capable de prendre
en compte le cas des sommets fixes 1
. Il est aussi possible d’utiliser des partitionneurs d’hypergraphe,
les arˆetes de migration deviennent alors des hyper-arˆetes de taille 2, la coupe de telles
hyper-arˆetes ´etant ´equivalente `a celle des arˆetes du graphe.
Les sommets fixes et les arˆetes de migration imposent le sch´ema de communication mais pas
le volume des messages ´echang´es. Affecter un sommet `a une partie de fa¸con `a engendrer un
message non autoris´e correspond `a une arˆete de migration coup´ee en plus. Un sommet est reli´e
par des arˆetes de migration `a un ou plusieurs sommets fixes chacun dans une partie diff´erente.
Au mieux une seule de ces arˆetes de migration n’est pas coup´ee (le sommet ne peut ˆetre que dans
une seule partie), alors la migration de ce sommet est autoris´e par la matrice de migration. Si
le sommet est dans une partie diff´erente de celles des sommets fixes auxquels il est connect´e, la
migration de ce sommet n’est pas autoris´ee et toutes les arˆetes de migration de ce sommets sont
coup´ees. Le partitionneur choisira donc de placer un sommet dans l’une des parties des sommets
fixes auxquels il est connect´e. La contrainte sur la taille des parties n’empˆeche pas ce choix car,
par construction de la matrice de migration, il y a toujours assez de sommets reli´es au sommet
fixe pour cr´eer la partie de la taille souhait´ee parmi ces derniers.
Bien que seul le sch´ema de communication soit impos´e, les tailles des messages sont respect´ees
lorsque le nombre de message (TotalZ) est minimal. Le partitionneur est libre de cr´eer n’importe
quelle partition induisant une matrice de migration avec les non-z´eros souhait´es. On cherche le
nombre de matrices de migration C
′ qu’il est possible d’obtenir apr`es le partitionnement. L’espace
des matrices de migration possibles peut ˆetre d´efini par un syst`eme d’´equations lin´eaires avec
autant d’inconnues, not´ees C
′
i,j , que de messages (d’une ancienne partie i vers une nouvelle partie
j). Les ´equations sont les contraintes de sommes sur les lignes et les colonnes ; il y en a M +N. Il y
a autant d’inconnues C
′
i,j que d’´el´ements Ci,j non nuls dans la matrice de migration C souhait´ee.
En notant Vi
le poids de l’ancienne partie i, V
′
j
la poids de la nouvelle partie j et W le poids
1. Il est en fait possible d’obtenir un partitionnement ´equivalent sans sommets fixes : il suffit de donner aux
sommets « fixes » un poids suffisamment grand, pour qu’il ne puisse pas y en avoir deux dans une mˆeme partie.
Les nouvelles parties sont ensuite renum´erot´ees pour que les sommets fixes soient dans les bonnes parties. Le
d´efaut de cette m´ethode est que le d´es´equilibre tol´er´e est plus important `a cause du poids de ces sommets.70 CHAPITRE 4. REPARTITIONNEMENT M × N
(a) Partition initiale de G en 5 parties.
1
2
3
4
5
(b) Graphe quotient Q de la partition initiale.
1
2
3
4
5
6
7
(c) Hypergraphe de repartitionnement
dessin´e par dessus le graphe quotient.
(d) Graphe G˜ auquel est ajout´e les sommets
fixes et arˆetes de migration.
(e) Partition de G˜ en 7 parties. Les arˆetes
de migration coup´ees sont en rouge, les
arˆetes de migration non-coup´ees en vert.
(f) Partition finale de G en 7 parties.
Figure 4.2 – Repartitionnement de 5 vers 7 parties.4.1. PARTITIONNEMENT BIAISE´ 71
total du graphe (W =
P
i
Vi =
P
j
V
′
j
), on a :
∀i ∈ J1, MK ,
X
j∈J1,NK
Ci,j>0
C
′
i,j = Vi (4.1)
∀j ∈ J1, NK ,
X
i∈J1,MK
Ci,j>0
C
′
i,j = V
′
j
(4.2)
La somme des ´equations sur les lignes (´equations 4.1) est ´equivalente `a la somme des ´equations
sur les colonnes (´equations 4.2) et donnent :
X
i∈J1,MK
j∈J1,NK
Ci,j>0
C
′
i,j = W
Ce syst`eme poss`ede donc M + N − 1 ´equations ind´ependantes 2
.
On sait que l’ensemble des solutions n’est pas vide car la matrice de migration C est une
solution. La dimension de l’espace solution est donc ´egale `a la diff´erence entre le nombre d’inconnues
(le nombre de messages dans la matrice C) et le rang du syst`eme. Si le nombre de messages
dans C n’est pas minimal (il n’atteint pas le rang du syst`eme), il existe une infinit´e de solutions
C
′ possibles. Le partitionneur peut donner une de ces matrice C
′
(´eventuellement diff´erente de
C) en minimisant la coupe du graphe enrichi. Plus le nombre de messages dans C est important
plus il y a de libert´e dans le partitionnement. La matrice de migration C
′
effectivement obtenue
apr`es repartitionnement peut ne pas ˆetre aussi bonne que la matrice C choisie. On pr´ef´erera donc
utiliser ce partitionnement biais´e avec des matrices de migration donnant un faible nombre de
messages (TotalZ).
4.1.2 Limitations des partitionneurs
Cette m´ethode partitionnement `a sommets fixes peut poser quelques probl`emes avec certains
partitionneurs, plus particuli`erement ceux utilisant des bissections r´ecursives [3].
Le premier probl`eme est que le placement et la num´erotation des nouvelles parties peut ne
pas ˆetre favorable aux bissections r´ecursives. Comme expliqu´e dans la section 3.3.1, lors d’une
bissection, chaque moiti´e regroupera plusieurs parties suivant leurs num´eros : g´en´eralement les
parties avec les plus petits num´eros sont regroup´ees dans une moiti´e et les plus grand num´eros
dans l’autre. Il est possible qu’une moiti´e regroupe des parties qu’on souhaite ´eloign´ees. Les
heuristiques peuvent avoir plus de mal `a cr´eer des parties et devoir travailler avec des graphes
non connexes.
Mais, certains cas sont encore plus graves. Mˆeme avec des bissections parfaites et un poids
tr`es important sur les arˆetes de migration, un partitionneur `a bissections r´ecursives peut ne pas
2. Il est possible de r´eduire encore le nombre d’´equations ind´ependantes lorsqu’il existe une somme partielle
de poids d’anciennes parties ´egale `a une somme partielle de poids de nouvelles parties. C’est-`a-dire que s’il existe
A ⊂ J1, MK et B ⊂ J1, NK tels que P
i∈A Vi =
P
j∈B V
′
j
et que pour tout (i, j) ∈ J1, MK × J1, NK tels que
(i ∈ A ∧ j /∈ B) ∨ (i /∈ A ∧ j ∈ B), Ci,j = 0, alors la somme des ´equations sur les lignes correspondant aux
anciennes parties de A est ´equivalente `a la somme des ´equations sur les colonnes correspondant aux nouvelles
parties de B : X
i∈A
j∈B
Ci,j>0
C
′
i,j =
X
i∈A
Vi =
X
j∈B
V
′
j72 CHAPITRE 4. REPARTITIONNEMENT M × N
1
2 3
4
(a) Partition intiale et sommets
fixes.
3 3
4
(b) Graphe quotient et hypergraphe
de repartitionnement.
(c) Partition finale k-aire direct.
1–2
3–4
(d) Premi`ere bissection.
(e) Partition finale avec bissections
r´ecursives.
Figure 4.3 – Exemple d’´echec de partitionnement avec bissections r´ecursives.
respecter le sch´ema de communication impos´e alors qu’un partitionneur k-aire direct trouverait
une solution [3, 60].
Par exemple, la figure 4.3 pr´esente un cas o`u la m´ethode des bissections r´ecursives ´echoue.
La grille est initialement partitionn´ee en 3 (figure 4.3a) et on souhaite la repartitionner en 4 en
utilisant l’hypergraphe de repartitionnement de la figure 4.3b. Un exemple de partition finale respectant
ce sch´ema est pr´esent´e sur la figure 4.3c. On essaye d’appliquer les bissections r´ecursives
sur ce graphe. Lors de la premi`ere bissection (figure 4.3d), le partitionneur regroupe les parties
1 et 2 d’un cot´e, et 3 et 4 de l’autre. La meilleure bissection possible est de coup´ee le graphe
verticalement par le milieu. Les parties 1 et 2 seront donc dans la partie gauche et les parties 3
et 4 dans la partie droite. Il n’est donc pas possible pour la partie 4 de reprendre des sommets de
l’ancienne partie 2. Chaque moiti´e est ensuite `a nouveau bipartitionn´ee pour obtenir la partition
finale pr´esent´ee sur la figure 4.3e. Sa matrice de migration est :
6 6
3 9
9 3
,4.2. PARTITIONNEMENT K-AIRE DIRECT (KGGGP) 73
alors que celle attendue, qui est celle de la partition de la figure 4.3c, est :
9 3
9 3
9 3
.
La partition de bissections r´ecursives coupent 39 arˆetes de migration alors qu’il est possible de
n’en couper seulement 36, mˆeme si on a suppos´e que les bissections ´etaient parfaites et le poids
des arˆetes de migration bien plus important que celui des arˆetes internes.
En pratique, la plupart des outils utilisent un multi-niveaux k-aire avec une partition initiale
du graphe contract´e calcul´ee par bissections r´ecursives. Dans le cas o`u les bissections r´ecursives
´echouent `a calculer une bonne partition initiale, le raffinement k-aire appliqu´e pendant la phase
d’expansion doit alors grandement modifier la partition initiale pour optimiser la coupe. Quand
l’heuristique de raffinement r´eussit `a corriger la partition initiale, ce qui est difficile comme
ces heuristiques sont souvent incr´ementales, le partitionneur est alors tr`es ralenti par la phase
d’expansion.
Pour cette raison, nous proposons une heuristique de partitionnement k-aire direct pouvant
ˆetre utilis´ee `a la place des bissections r´ecursives en tant que m´ethode de partitionnement initiale
dans un partitionneur.
4.2 Partitionnement k-aire direct (KGGGP)
L’heuristique du Greedy Graph Growing Partitioning (GGGP) est une heuristique gloutonne
largement utilis´ee dans le cadre du bipartitionnement [5, 11, 29]. En partant de deux sommets
« graines », les autres sommets sont ajout´es un `a un dans chacune des parties. Nous proposons
d’´etendre cette m´ethode dans le cas du partitionnement k-aire. Nous l’appellerons dans ce cas
KGGGP (k-way greedy graph growing partitioning).
4.2.1 Description de l’algorithme
Cette heuristique s’inspire en grande partie de celle de Fiduccia et Mattheyses [17] (abr´eg´ee
FM), `a la diff´erence que les sommets ne sont initialement dans aucune partie et sont `a distribuer
dans k parties. Cette m´ethode peut ˆetre vue comme un raffinement FM k + 1-aire o`u la partie
suppl´ementaire (que l’on num´erotera −1) contient initialement tous les sommets et doit ˆetre vide
dans la partition finale.
Pour r´ealiser cet algorithme, on consid`ere tous les d´eplacements possibles des sommets sans
parties vers une des k parties. Chaque it´eration de l’algorithme 5 place un sommet sans partie
dans une partie p. A chaque it´eration, on s´electionne le meilleur d´eplacement, d’ ` apr`es un crit`ere
de s´election bas´e sur la coupe, qui respecte l’´equilibre final (c’est-`a-dire que le poids Wp de la
partie p ne d´epassera pas la taille maximum permise avec un facteur de d´es´equilibre ǫ). Il existe
plusieurs crit`eres de s´election qui seront d´etaill´es plus loin dans cette section. Il est possible
qu’aucun sommet ne respecte la contrainte d’´equilibre, particuli`erement dans le cas d’un graphe
contract´e dans le cadre d’un algorithme multi-niveaux, o`u des sommets peuvent avoir un poids
tr`es important par rapport au poids total du graphe. Dans ce cas, l’´equilibre ne pourra pas ˆetre
respect´e et le meilleur d´eplacement est choisi ind´ependamment du poids du sommet et de la
partie cible. Une fois un sommet s´electionn´e, il est alors d´eplac´e et verrouill´e, c’est-`a-dire qu’il
ne sera plus consid´er´e pour d’autres d´eplacements.
Le crit`ere de s´election calcule le score si(u) d’un d´eplacement `a partir des parties de ses voisins
(cf. section suivante). Ainsi lorsqu’un sommet est d´eplac´e, le crit`ere de s´election de chacun de
ses voisins doit ˆetre mis `a jour.74 CHAPITRE 4. REPARTITIONNEMENT M × N
p
v
s = sp(v) = sp'(v')
déplacement
de v dans p
tableau des
scores
tableau des
déplacements
p'
v'
déplacement
de v' dans p'
...
score min
score max
Figure 4.4 – Structure de donn´ees inspir´ee de Fiduccia et Mattheyses, illustrant le cas des
d´eplacements de v dans p et de v
′ dans p
′ ayant un mˆeme score s.
L’algorithme 5 s´electionne le meilleur d´eplacement globalement. Mais il existe d’autres variantes
possibles pour s´electionner un d´eplacement afin d’obtenir une partition ´equilibr´ee [29].
Par exemple, la partie de destination du d´eplacement est choisie l’une apr`es l’autre (m´ethode
appel´ee round-robin), ou elle peut ˆetre la partie dont le poids courant est le plus faible. Dans ces
deux cas, on choisit le meilleur d´eplacement seulement vers la partie choisie.
Pour trouver rapidement le meilleur d´eplacement d’apr`es le crit`ere choisi, la structure de
donn´ees pr´esent´ee par Fiduccia et Mattheyses est utilis´ee. Cette structure de donn´ees (r´esum´ee
sur la figure 4.4) utilise un tableau `a chaque case duquel est associ´ee une valeur du score utilis´ee
comme crit`ere de s´election (le gain de coupe du d´eplacement dans le cas de FM). Chaque case
de ce tableau donne la liste doublement chain´ee des d´eplacements correspondant `a ce score. Ce
tableau des scores permet de s´electionner rapidement un d´eplacement avec un gain donn´e (ici,
le plus grand). Un autre tableau r´ef´eren¸cant les ´el´ements des listes chain´ees par leur num´ero de
sommet permet de les retrouver rapidement pour effectuer une mise `a jour du gain. Dans notre
algorithme k-aire ce tableau est ´etendu avec une seconde dimension correspondant `a la partie du
d´eplacement. Le double chainage permet d’effectuer en temps constant le changement de liste
d’un ´el´ement apr`es une mise `a jour ou son retrait quand le sommet est plac´e dans une partie.
En pratique, notre mise en œuvre de cet algorithme utilise deux tableaux de score pour classer
les d´eplacements. Initialement, le premier contient tous les d´eplacements et le second est vide.
Les d´eplacements sont recherch´es d’abord dans la premi`ere structure, lorsque qu’un d´eplacement
ne respectant pas la contrainte d’´equilibre est trouv´e, il est d´eplac´e dans la seconde. En effet,
le poids des parties ne faisant que croˆıtre, il ne respectera pas la contrainte d’´equilibre dans le
futur, il est inutile de le consid´erer `a nouveau pour ˆetre d´eplacer. Quand la premi`ere structure4.2. PARTITIONNEMENT K-AIRE DIRECT (KGGGP) 75
est vide, il n’y a plus de d´eplacements respectant la contrainte d’´equilibre, la seconde structure
est alors utilis´ee jusqu’`a la fin de l’algorithme et le poids de la partie n’est plus v´erifi´e.
Il est tr`es simple de g´erer le cas des sommets fixes avec cette m´ethode. En effet, les sommets
fixes sont simplement plac´es dans leur parties respectives initialement et ne sont pas consid´er´es
dans les d´eplacements possibles.
Algorithme 5 Heuristique de partitionnement gloutonne (KGGGP)
Entr´ee : Graphe G `a partitionner
Entr´ee : k parties ne contenant que les sommets fixes
Entr´ee : Partition o`u tout les sommets fixes sont dans leur partie respective, et les autres
sommets sont dans la partie −1
tant que il existe des sommets dans la partie −1 faire
S´electionner un sommet v sans partie dont le d´eplacement vers une partie
p a un crit`ere de s´election sp(v) maximal et tel que Wp + wv ≤ (1 + ǫ) ×
W/k
si un tel sommet n’existe pas alors
S´electionner un sommet v sans partie dont le d´eplacement vers une partie
p a un crit`ere de s´election sp(v) maximal
fin si
Placer le sommet v dans la partie p
Wp ← Wp + wv
pour tout voisin u de v faire
pour tout partie i faire
Mettre `a jour le crit`ere de s´election si(u)
fin pour
fin pour
fin tant que
retourner Partition de G en k parties
4.2.2 Crit`eres de s´election
Il existe plusieurs crit`eres pour ´evaluer la qualit´e des d´eplacements. On note sp(v), le score du
d´eplacement du sommet v vers la partie p. Les d´eplacements sont ´evalu´es en fonction des arˆetes
les connectant aux diff´erentes parties. On notera Ni(u) le poids des arˆetes connectant le sommet
u `a des voisins dans la partie i, et N−1(u) le poids des arˆetes le connectant `a des sommets sans
partie. On appelle arˆete interne, une arˆete dont les deux extr´emit´es sont dans la mˆeme partie et
on appelle arˆete externe (ou coup´ee), une arˆete dont les deux extr´emit´es sont dans des parties
diff´erentes.
Comme avec la m´ethode FM, il est possible d’utiliser la formule du gain de coupe en consid´erant
que les sommets sans parties sont dans une partie num´erot´ee −1. Le gain d’un sommet
u d´eplac´e de la partie i vers j se calcule par la diff´erence entre les arˆetes vers la nouvelle partie
j, qui ´etaient coup´ees mais ne le seront plus, et les arˆetes vers l’ancienne partie i, qui ´etaient
internes et seront coup´ees. En reprenant la formule du gain : gi→j (u) = Nj (u) − Ni(u), le crit`ere
de s´election bas´e sur le gain pour d´eplacer u dans i est si(u) = g−1→i(u) = Ni(u) − N−1(u).
Battiti et Bertossi [5] proposent d’utiliser un autre crit`ere, appel´e diff. Bien que con¸cu pour le
bipartitionnement, ce crit`ere peut ´egalement s’appliquer dans le cas du partitionnement k-aire.
Ce crit`ere ne s’int´eresse plus aux voisins sans partie, mais utilise la diff´erence entre les nouvelles
arˆetes internes (voisins dans la partie vis´ee) et les nouvelles arˆetes coup´ees (voisins dans les autres76 CHAPITRE 4. REPARTITIONNEMENT M × N
i
j
–1
u
Figure 4.5 – Diff´erentes arˆetes autour du sommet sans partie u qui se trouve `a la fronti`ere des
parties i et j.
parties) : si(u) = diffi
(u) = Ni(u) −
P
j6=i Nj (u). En effet, minimiser la coupe avec la partie −1
qui finira par disparaitre peut paraitre inutile alors que les arˆetes vers les autres parties font
partie de la coupe finale. D’autre part, en maximisant le nombre d’arˆetes internes (Ni(u)), on
esp`ere r´eduire le nombre d’arˆetes qui devront ˆetre coup´ees plus tard.
La figure 4.5 pr´esente les diff´erentes arˆetes autour du sommet u : en vert, les arˆetes correspondant
`a Ni(u) ; en rouge `a Nj (u) ; et en bleu `a N−1(u). On suppose que toutes les arˆetes de
cet exemple ont un poids unitaire. Si on consid`ere le d´eplacement de u dans la partie i, le gain
est g−1→i(u) = 0 : initialement 3 arˆetes sont coup´ees (en vert et rouge), apr`es d´eplacement 3
arˆetes sont toujours coup´ees (cette fois en bleu et rouge). Le crit`ere diff ne s’int´eresse pas aux
arˆetes avec les sommets sans partie (en bleu) mais seulement `a la diff´erence entre les futures
arˆetes internes (en vert) et les arˆetes externes avec les « vraies » parties (en rouge). On a donc
diffi
(u) = 2 − 1 = 1.
4.2.3 Complexit´e
L’algorithme de partitionnement d´eplace une fois chaque sommet libre. Il y a donc autant
d’it´erations de la boucle principale que de sommets non fixes (au plus |V |). La boucle principale
comporte les ´etapes de s´election, d´eplacement et mise `a jour des structures de donn´ees.
Lors de la s´election, chaque d´eplacement n’est consid´er´e qu’une ou deux fois : s’il n’est pas
accept´e la premi`ere fois, il est retir´e de la premi`ere liste des d´eplacements et plac´e dans la seconde ;
dans la seconde liste, un d´eplacement n’est jamais rejet´e. La complexit´e en temps totale de la
s´election est donc au pire proportionnelle au nombre de d´eplacements possibles, c’est-`a-dire
O(k|V |).
Le d´eplacement est une op´eration simple en temps constant. Cela n’est que le changement
d’une valeur dans le tableau repr´esentant la partition.
La mise `a jour des structures de donn´ees apr`es le d´eplacement d’un sommet, n´ecessite de
visiter tous les voisins du sommet d´eplac´e. Pour chaque voisin, il est n´ecessaire de mettre `a jour
le crit`ere de s´election vers chacune des k parties. Comme ces op´erations sont effectu´ees pour
chaque sommet du graphe, la complexit´e en temps totale des mises `a jour est au pire O(k|E|).
La complexit´e en temps de l’algorithme est donc au pire O(k|E|), en consid´erant que |V | est
domin´e par |E|. La complexit´e en m´emoire est principalement due au stockage des d´eplacements
possibles, elle est donc au pire O(k|V |).4.2. PARTITIONNEMENT K-AIRE DIRECT (KGGGP) 77
4.2.4 Am´eliorations
Plusieurs variantes peuvent ˆetre utilis´ees pour am´eliorer la qualit´e des partitions produites
par l’algorithme.
a) S´election al´eatoire et r´ep´etition
Lors de la s´election des sommets, plusieurs peuvent avoir le mˆeme score. Si le premier sommet
trouv´e est choisi, la s´election est biais´ee par l’ordre de parcours des sommets ou par le dernier
d´eplacement. En effet, lors de la mise `a jour, les voisins dont le score s’est am´elior´e se retrouvent
en d´ebut de liste, ce qui tend `a faire grossir la partie toujours dans la mˆeme direction. En
s´electionnant un sommet al´eatoire parmi les meilleurs, on ´evite ce biais. Cela permet d’obtenir
des partitions diff´erentes avec diff´erentes ex´ecutions de l’algorithme. Comme cet algorithme est
tr`es rapide lorsqu’il est appliqu´e dans le cadre d’un partitionnement multi-niveaux, il devient
int´eressant de le r´ep´eter plusieurs fois et de garder la meilleure partition. Cela permet aussi une
version parall`ele triviale o`u chaque nœud calcule une partition puis partage la meilleure.
b) Graines
Bien que l’algorithme puisse s’appliquer sans aucun sommet initialement dans une partie, les
crit`eres de s´election ne seront pas tr`es efficaces pour le choix des premiers sommets. Il est donc
int´eressant de choisir avant le d´ebut de l’algorithme certains sommets qui initieront les parties.
Il existe plusieurs possibilit´es pour choisir ces sommets qu’on appelle « graines ».
Graines al´eatoires. k sommets sont choisis al´eatoirement dans le graphe pour servir de graines
`a chacune des parties. Ces techniques se combinent bien avec la r´ep´etition de l’heuristique et
permettent encore plus de vari´et´e dans les tentatives pour trouver la meilleure partition possible.
Graines au centre des parties. La r´ep´etition de l’heuristique peut ´egalement ˆetre utilis´ee
pour trouver des graines de fa¸con plus intelligente. Apr`es une premi`ere passe `a l’aide de graines
choisies d’une mani`ere quelconque, les centres 3 ou des « pseudo-centres 4 » des parties sont calcul´es
et servent de graine `a l’it´eration suivante. Cette m´ethode est propos´ee par Diekmann et al.
dans le cadre du Bubble Partitioning [14].
Graines ´eloign´ees. Diekmann et al. [14] proposent ´egalement un algorithme pour optimiser
l’ensemble des graines initiales. L’algorithme 6 permet de construire un ensemble de k graines
bien ´eloign´ees les unes des autres. En partant d’un sommet quelconque, on recherche le sommet
le plus ´eloign´e `a l’aide d’un parcours en largeur. Les graines suivantes sont trouv´ees de fa¸con
similaire en initialisant le parcours en largeur avec les n graines d´ej`a trouv´ees. La seconde boucle
permet d’am´eliorer cet ensemble. On retire une `a une les graines de l’ensemble et on en cherche
une nouvelle, toujours `a l’aide d’un parcours en largeur. Cette derni`ere boucle peut ˆetre r´ep´et´ee
jusqu’`a ce que l’ensemble ne change plus ou r´ep´et´ee un nombre limit´e de fois. La complexit´e d’un
parcours en largeur ´etant O(|E|), la complexit´e de la cr´eation de l’ensemble initiale ou d’une
passe d’optimisation est O(k|E|).
3. Le centre d’un graphe est un sommet avec une excentricit´e minimale.
4. La recherche du centre d’un graphe est complexe. Nous pr´ef´erons donc chercher un « pseudo-centre » `a l’aide
d’un parcours en largeur `a partir de la fronti`ere de la partie. Le dernier sommet parcouru est le plus ´eloign´e de la
fronti`ere, il est donc s´electionn´e en tant que « pseudo-centre »78 CHAPITRE 4. REPARTITIONNEMENT M × N
Algorithme 6 Cr´eation d’un ensemble de k graines ´eloign´ees