Recherche locale par satisfaction de contraintes

Une alternative aux algorithmes présentés ci-dessus consiste à redéfinir le problème de l’appariement comme un PSC (voir section 2.3.1). Dans ce domaine, l’AMC [Minton

et al., 1993] est une méthode de recherche locale qui semble bien adaptée à la recherche

d’un appariement maximal.

A l’initialisation du système, toutes les variables de la clause h sont appariées ; la façon la plus simple est de réaliser un appariement aléatoire. L’algorithme visite ensuite un état voisin en modifiant l’appariement d’une variable à la fois de façon à minimiser le nombre de conflits à l’intérieur du système. Un conflit apparaît si, étant donné deux littéraux p(x, y) dans h et p(x′, y′_{) dans ex, on a x}′₌π(x) et y′, π(y) (ou x′, π(x) et

y^′=π(y)). En réduisant le nombre de conflits, on augmente le nombre de contraintes satisfaites (i.e. le nombre de littéraux ne contenant que des variables appariées) ce qui accentue les chances d’identifier un appariement connexe.

L’algorithme s’arrête lorsqu’une solution complète au PSC a été trouvée (dans ce cas, le nombre de conflits est nul) ou lorsque le nombre maximal d’itérations (variable

maxIter dont la valeur est fixée par l’utilisateur) a été atteint ; dans ce cas, l’état courant du système (le dernier appariement App trouvé) est retourné. L’algorithme AMC original, appelé AMC_non_Guidé (avec initalisation aléatoire du système), est le suivant.

3.3. Stratégies d’appariement global

ProcédureAMC_non_Guidé

Input: entier maxIter, clause h, clause ex appCourant← Initialise_Appariement () ; pour i← 1 to maxIter faire

x← Variable_En_Conflit (h, ex, appCourant) ;

a← Valeur_Appariement_Minimale (h, ex, appCourant) ; Apparier la variable x avec la variable a;

si NombreConflits(appCourant)= 0 alors Retourner appCourant;

finsi finpour

Retourner appCourant;

Algorithme 5:AMC original (AMC_non_Guidé).

Les trois fonctions principales sont les suivantes.

La fonction Initialise_Appariement apparie toutes les variables de la clause h de façon aléatoire (voir figure 3.9a). Si l’appariement est de type 1-1, on veillera à ne pas apparier plusieurs fois une variable de ex.

La fonction Variable_En_Conflit construit la liste des variables en conflit dans h et ren-voie l’une d’elles ; dans AMC_non_Guidé, le choix de cette variable est aléatoire. Dans l’exemple de la figure 3.9a, il y a un conflit sur les arêtes(x₂, x3) et (x₁, x4) : l’ensemble des variables en conflit est alors égal à {1, 2, 3, 4}. La fonction Variable_En_Conflit renvoie alors une de ces quatre variables.

La fonction Valeur_Appariement_Minimale établit la liste des variables de la clause

ex avec lesquelles v_i (renvoyée par Variable_En_Conflit) est appariable⁷ et calcule le nombre de conflits que les appariements pourraient générer. Elle renvoie alors la va-riable qui minimise le nombre de conflits dans le système. Dans l’exemple, suite à l’ini-tialisation, x₂ est en conflit une fois, x₃ deux fois et x₄ une seule fois. Si l’appariement de la variable x3 est modifié et passé sur la variable a3(figure 3.9b), alors le système n’a plus de conflit : l’appariement est total.

Clause h Clause ex

Initialisation du système de façon aléatoire

Itération suivante : le système n'a plus de conflits. Une solution

complète a été trouvée. Clause h _{Clause ex} x1 x5 x2 x3 x4 a5 a2 a1 a4 a3 x5 x1 x4 ^x3 x2 a1 a5 a2 a3 a4

Figure 3.9 –En haut (figure 3.9a) : la fonction Initialise_Appariement apparie toutes les variables. En

bas (figure 3.9b) : apparier la variable x3avec la variable a3fait disparaître les conflits.

Dans l’algorithme AMC_non_Guidé, la recherche d’une solution ne repose que sur la notion de conflit et consiste à identifier toutes les variables en conflit, sans aucune sélection. De ce point de vue, la modification des appariements reste locale à une paire de variables et ne réduit pas le nombre de variables candidates à l’appariement. Pour limiter cette combinatoire, nous utilisons la matrice INC et le degré d’inclusion I_π pour guider la recherche des appariements, en complément du nombre de conflits. Ce nouvel algorithme, appelée AMC_Guidé, est décrit sur la page suivante.

La procédure Initialise_Appariement_Guide utilise les valeurs de la matrice INC pour apparier, de façon gloutonne, les variables de h avec celles de ex, c’est-à-dire que chaque variable xi est appariée à la variable x_m^′ telle que, quelle que soit x^′_m, la valeur de INC [x_i, x^′_m] soit maximale (valeur maximale dans la ligne INC[x_i, ]. La procédure

Valeur_Appariement_Minimale_Guide renvoie une variable x^′_m dans ex telle que l’ap-pariement de xi(renvoyée par Variable_En_Conflit_Guide) avec x^′_mminimise le nombre de conflits et maximise la valeur de l’indice I_π(h, ex, appCourant).

Si l’appariement est unique et que la clause h contient plus de variables que la clause

ex, un appariement total ne pourra pas être trouvé. Dans ce cas, l’algorithme s’arrête au

3.3. Stratégies d’appariement global

ProcédureAMC_Guidé

Entrées: matrice INC, entier maxIter, clause h, clause ex, entier tmax

listeTaboue= ∅ //(file First In First Out (FIFO) de taille n) ; compteur← 0;

appCourant← Initialise_Appariement_Guide () ; appPrecedent← appCourant ;

meilleurApp← appCourant ; pour i ← 1 to maxIterfaire

si I_π (h, ex , appCourant)=1 alors Retourner appCourant;

sinon

si appCourant∈ listeTaboue alors

appCourant← Initialise_Appariement_Guide () ; sinon

SupprimerTête(listeTaboue); Ajouter(appCourant, listeTaboue) ;

si I_π(h, ex , appCourant)= Iπ^{(h, ex ,appPrecedent) alors}

compteur← compteur +1; finsi

si compteur = t_maxalors compteur← 0;

appCourant← Initialise_Appariement_Guide (); sinon

si I_π (h, ex , appCourant)> Iπ ^{(h, ex , meilleurApp) alors}

meilleurApp← appCourant ; appPrecedent← appCourant ; finsi finsi finsi finsi

x← Variable_En_Conflit (h, ex, app) ;

a← Valeur_Appariement_Minimale_Guide (h, ex, app) ; Apparier la variable x avec la variable a ;

finpour

Retourner meilleurApp;

Algorithme 6:AMC modifié (AMC_Guidé).

Lorsque l’algorithme est guidé par la fonction objectif I_π, il peut se retrouver piégé dans des optima locaux de la fonction : il visite alors souvent les mêmes états voisins et a tendance à atteindre toujours le même optimum local. L’introduction d’une liste taboue contenant les n états précédemment visités permet de détecter ce cas de figure (dans

notre cas, la liste taboue est implémentée par une file FIFO et sa longueur n est fixée de façon arbitraire à 10). Si l’algorithme arrive dans un état appartenant à la liste, le système est perturbé pour le forcer à atteindre un état non encore visité. Cette perturbation peut être réalisée par le changement aléatoire de l’appariement d’une variable ou un appel à la fonction Initialise_Appariement_Guide qui réinitialise alors l’appariement de toutes les variables. Nous utilisons ici cette deuxième solution car elle perturbe le système de façon plus importante que le changement d’une seule variable et augmente ainsi la probabilité de sortir d’un optimum local.

L’algorithme peut également se trouver piégé sur un plateau de la fonction objectif : pendant un nombre d’itérations t, la valeur de I_πreste constante quels que soient les états visités. La variable compteur comptabilise le nombre d’itérations pendant lesquelles la valeur de I_π reste constante : si la valeur de compteur dépasse une valeur seuil définie par l’utilisateur (dans notre cas, ce seuil est fixé à 10 itérations) alors le système est perturbé de la même façon que précédemment.

3.4 Recherche d’Arbres Partiellement Couvrants

Dans certains domaines, il est important d’identifier des appariements connexes, c’est-à-dire des appariements qui conduisent à des SSC connexes. Or, les algorithmes présentés dans la section précédente ne sont pas adaptés à ce type de recherche car ils ne peuvent pas garantir de trouver un appariement connexe. Nous proposons ici une autre stratégie d’appariement qui décompose deux clauses (ou graphes) en un ensemble de SSC connexes. La recherche des plus grandes SSC possibles permet d’identifier la SSCM.