Академический Документы
Профессиональный Документы
Культура Документы
: 2015-2016
Université de Gabès
Faculté des Sciences de Gabès
Département Informatique
Réalisé Par :
Résumé :
L’algorithme Solve and Decompose est un algorithme qui est combiné à des
méthodes de résolution exactes pour résoudre des problèmes d’optimisation.
L’objectif de notre travail est d’implémenter la version basique de
l’algorithme Solve and Decompose et ensuite d’apporter des améliorations à cet
algorithme afin de le rendre plus efficace pour résoudre les problèmes
d’optimisations.
Mots clés:
Abstract:
Key-words:
SAYOUTI S. Abdoulaye
REMERCIEMENT
Introduction Générale 6
Conclusion et Perspectives 36
BIBLIOGRAPHIE 37
1.1 Echiquier 4 x 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2 Formulation du problème des quatre reines. . . . . . . . . . . . . . . . . . . 10
1.3 Deux solutions possibles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.4 Formulation du Problème du Voyageur de Commerce. . . . . . . . . . . . . 12
INTRODUCTION GÉNÉRALE
Dans notre vie quotidienne, la notion de contrainte est naturellement très présent. Il s’agit
aussi bien de ranger des objets de formes différentes dans une boîte, d’établir des emplois du
temps ou même de planifier le trafic aérien pour limiter les retards ou pour éviter les colli-
sions. La notion de "Problème de Satisfaction de Contrainte" ou CSP( "Constraint Satisfac-
tion Problem" en anglais) désigne l’ensemble de ces problèmes, définis par des contraintes, et
consistant à chercher une solution les respectants. Dans le même sens la notion de "Problème
d’Optimisation Combinatoire sous Contraintes" ou COP(" Combinatorial Optimization Pro-
blem" en anglais) désigne l’ensemble des problèmes, définis par des contraintes, et consiste à
chercher la solution optimale. Généralement la résolution de ces problèmes variés est com-
binatoire dans le sens où il faut envisager un très grand nombre de combinaisons avant d’en
trouver une qui satisfasse toutes les contraintes. Intégrée à un langage de programmation, la
programmation par contraintes (PPC) est un nouveau paradigme de programmation pour
formuler et résoudre ces problèmes combinatoires.
Dans un cas idéal, l’utilisateur définit le problème à résoudre, le donne ensuite à l’ordina-
teur, l’ordinateur le résout et donne une solution. En raison de l’aspect fortement combina-
toire des problèmes à traiter, la puissance de calcul des ordinateurs ne suffit pas pour exami-
ner toutes les combinaisons possibles en un temps acceptable. Pour cela, des raisonnements
et des heuristiques issues traditionnellement de « l’intéligence artificielle » sont introduits
pour réduire la combinatoire et de guider la recherche vers les bonnes combinaisons.
Ce mémoire est structuré en deux chapitres. Dans le premier chapitre, nous présentons les
notions de base sur la programmation par contraintes et sur l’optimisation combinatoire sous
contraintes. Dans le deuxième chapitre, nous présentons l’algorithme Solve and Decompose
qui est une heuristique permettant de résoudre les problèmes d’optimisation de façon plus
efficace.
CHAPITRE 1
PROGRAMMATION PAR CONTRAINTES ET
OPTIMISATION COMBINATOIRE SOUS CONTRAINTES
1.1 Introduction
La programmation par contraintes est une technique de résolution des problèmes com-
binatoires complexes issue de la programmation logique et de l’intelligence artificielle. Elle
consiste à modéliser un problème par un ensemble de variables et de contraintes, imposant
des conditions sur l’instanciation possible d’un sous-ensemble de ces variables définissant une
solution du problème. Ainsi, dans ce chapitre, nous donnons quelques définitions et notations
qui vont constituer le socle de la suite de ce mémoire.
La suite de ce chapitre est composé de quatre sections. Dans la section 1.2 et la section 1.3
nous donnons une définition sur les problèmes de satisfaction de contraintes et les problèmes
d’optimisation combinatoire sous contraintes. Ensuite, dans la section 1.4 nous donnons
quelques méthodes de résolution exactes et une définition des heuristiques d’ordre de choix
de variables et de valeurs. Enfin dans la section 1.5 nous concluons le chapitre.
– Contrainte en extension :
Q
Définir une contrainte cj en extension revient à donner tous les tuples xi ∈Var(cj ) D(xi )
autorisés par cette contrainte. L’ensemble de ces tuples peut être nommé par support(cj ).
Cependant, la contrainte cj peut être définie par l’ensemble des tuples qui ne sont
pas autorisées par la contrainte cj . Dans ce cas l’ensemble de ces tuples, peut être
nommé par conflicts(cj ). L’exemple du CSP ci-dessus contient deux contraintes, à sa-
voir c1 ≡ (x1 + x2 = x3 ) et c2 ≡ (| x1 − x3 | = 6 1). Nous avons donc : supports(c1 ) ≡
{(1,1,2),(1,2,3),(2,1,3)} et supports(c2 ) ≡ {(1,3),(2,2),(3,3)}.
– Contrainte en intention :
Définir une contrainte cj en intention revient à exprimer avec des propriétés mathé-
matiques ou logiques les tuples autorisés par la contrainte cj . Chacune des contraintes
de l’exemple est donnée en formule mathématique c1 ≡ (x1 + x2 = x3 ) et c2 ≡ (| x1 − x3
| 6= 1). Ces deux contraintes c1 et c2 sont défini en intention.
– Contrainte globale :
Une contrainte globale peut aider à résoudre un problème plus efficacement qu’un
ensemble de contraintes binaires dans la mesure où elle véhicule des informations sur
ce problème. Dans l’exemple ci-dessous, le fait d’utiliser la contrainte globale All-
Diff permet d’affirmer immédiatement que le problème n’admet pas de solution, car |
xi ∈X D(xi ) | <| x |. Cette propriété est exploitable lorsque nous utilisons la contrainte
S
AllDiff, mais elle ne peut pas être exploitée en utilisant chacune des trois contraintes
binaires séparément {6= (x1 , x2 ), 6= (x1 , x3 ), 6= (x2 , x3 )}.
Exemple 1 :
L’espace de recherche :
L’espace de recherche d’un CSP P = (X , D, C ) est défini par un ensemble fini Ω qui
est constitué de toutes les affectations totales. L’ensemble des contraintes C divise Ω en une
partition de deux ensembles Ω+ et Ω− . L’ensemble Ω+ contient toutes les solutions de P
et l’ensemble Ω− contient toutes les affectations totales et incohérentes de P. Résoudre P
revient à trouver un élément de Ω+ .
Remarque :
Un CSP est dit binaire s’il ne contient que des contraintes binaires.
Le but du problème des n reines est de placer n reines d’un jeu d’échecs sur un échiquier
de n x n cases sans que les reines ne puissent se menacer mutuellement, conformément aux
règles du jeu d’échecs. Par conséquent, deux reines ne devraient jamais partager la même
ligne, colonne, ou diagonale. La figure 1.1 ci-dessous illustre l’échiquier d’une instance du
problème des n reines avec quatre reines.
4
0Z0Z
3
Z0Z0
2
0Z0Z
1
Z0Z0
1 2 3 4
Dans le modèle ci-dessus, (1) représente un ensemble de quatre variables, où chaque va-
riable xi représente une reine ; (2) représente le domaine de chaque variable de sorte que
xi = j si la reine i se trouve sur la colonne j ; (3) contraint deux reines à ne pas êtres sur la
même colonne ; enfin (4) et (5) représentent les contraintes de diagonale. La contrainte de
ligne est implicitement formulée par les quatre variables xi distinctes. La figure 1.3 présente
les deux solutions possibles de ce problème :
4
0L0Z 4
0ZQZ
3
Z0ZQ 3
L0Z0
2
QZ0Z 2
0Z0L
1
Z0L0 1
ZQZ0
1 2 3 4 1 2 3 4
zi a pour domaine D(zi ) = {di1 , di2 , ..., din }. La formulation en programmation par contrainte
du problème du voyageur de commerce utilise la contrainte Element pour associer à chaque
variable zi le coût de la distance parcourue après le départ de la ville i.
Un modèle COP d’un TSP à n villes est :
Remarque :
pour laquelle var(c) ⊆ (var(Ap) {< x, v >}). Si toutes les contraintes sont satisfaites,
S
La cohérence d’arc :
La cohérence d’arc (en anglais : Arc Consistency (AC)) est basée sur la notion de support
et a été initialement définie pour les CSP binaires.
Un utilisateur novice de ces algorithmes peut penser qu’un algorithme qui maintient
à chaque point de décision une cohérence locale forte est toujours meilleur que le même
algorithme maintenant une propriété de cohérence locale plus faible. En pratique, ceci n’est
pas toujours vrai, car en général, plus la propriété de cohérence maintenue est forte plus
grande est la complexité de l’algorithme de filtrage.
Forward Checking
L’algorithme Forward Checking (FC ) est l’un des algorithmes de propagation. Sur un
CSP binaire, après chaque affectation d’une variable xi par une valeur vi , l’algorithme FC
filtre le domaine de chaque variable xj non encore affectée et liée par une contrainte avec xi ,
n’enlevant du domaine de xj toute valeur vj telle que l’affectation {< xi , vi >, < xj , vj >}
est incohérente .
Algorithme MAC
L’algorithme MAC (Maintaining Arc Consistency) est l’un des algorithmes les plus
connus. Après chaque affectation d’une variable, il maintient la propriété de cohérence d’arc.
Cet algorithme filtre plus de domaines que FC, mais ça ne lui garantit pas d’être le meilleur
des deux. En effet, en fonction de l’instance de problème traitée, l’effort de filtrage supplé-
mentaire introduit par le maintien de la cohérence d’arc après chaque affectation peut ne
pas compenser la réduction de l’espace de recherche.
conséquent, si cette borne est moins bonne que la qualité de la meilleure solution trouvée
jusqu’à présent, l’algorithme peut ne pas développer ce sous-arbre.
Une heuristique de choix de variables très populaire est l’heuristique minDom qui sé-
lectionne en premier la variable qui a le plus petit domaine. Les ex-aequo peuvent être dé-
partagés en utilisant le degré dynamique des variables (le nombre de contraintes auxquelles
cette variables appartient et qui ne sont pas encore satisfaites). Une autre heuristique est
d’utiliser le ratio entre la taille des domaines et le degré des variables.
Une fois que la prochaine variable à affecter est sélectionnée, il faut lui choisir une valeur.
Si le problème à résoudre consiste à trouver uniquement une solution et que cette solution
existe, alors l’ordre de choix des valeurs influence beaucoup le temps de calcul nécessaire pour
trouver cette solution. En effet, pour trouver rapidement une solution, il serait intéressant
de choisir d’abord les valeurs qui restreignent le moins possible le reste des variables non
encore affectées. En revanche, si le problème consiste à trouver toutes les solutions possibles
ou si le problème n’admet pas de solution, alors, toutes les valeurs de chaque variable vont
être considérées et donc, l’ordre de choix des valeurs n’a plus d’importance.
1.5 Conclusion
Dans ce chapitre, nous avons passé en revue les principaux techniques et algorithmes de
résolution de problèmes de satisfaction de contraintes et de problèmes d’optimisation com-
binatoire basées sur la recherche complète. Nous avons également donné quelques exemples
de problème de satisfaction de contrainte et d’optimisation combinatoire sous contraintes.
Cependant, des stratégies peuvent être combinées à ces méthodes de résolution exacte afin
d’obtenir rapidement la solution optimale ou une solution proche de la solution optimale.
Ainsi, dans le prochain chapitre, nous présentons l’ algorithme Solve and Decompose qui
combine méthodes de résolution exactes et heuristiques de recherche afin de résoudre les
problèmes d’optimisation de façon plus efficace .
CHAPITRE 2
L’ALGORITHME SOLVE AND DECOMPOSE
2.1 Introduction
Dans la pratique, de nombreux problèmes ont des espaces de recherche trop grands pour
une recherche exhaustive. On peut souvent trouver une solution tout en recherchant seule-
ment dans une petite fraction de l’espace de recherche reposant sur des heuristiques soigneu-
sement réglées pour guider la recherche vers les régions de l’espace de recherche qui sont
susceptibles de contenir de meilleurs solutions. Dans cette optique, A. Lamine, M. Khema-
khem, B. Hnich et H. ChabChoub ont ainsi proposé [1] l’algorithme Solve and Decompose
dont la principale caractéristique est d’identifier et d’explorer les parties les plus prometteuses
de l’espace de recherche pour atteindre la solution optimale dans un temps acceptable. Ainsi
notre principal objectif sera d’apporter des améliorations à cet algorithme et ensuite de le
comparer à l’algorithme de recherche en profondeur (en anglais : Depth-First Search (DFS)).
La suite de ce chapitre est organisée comme suit : Nous présentons l’algorithme Solve
and Decompose et son principe de fonctionnement dans la section 2.2. Dans la section 2.3
nous faisons quelques critiques de l’algorithme Solve and Decompose et nous présentons les
améliorations que nous apportons. Dans la section 2.4 nous présentons les implémentations
effectuées pour la nouvelle version de l’algorithme Solve and Decompose. Et dans la section
2.5 nous concluons le chapitre.
identifiés et résolus en premier pour atteindre la solution optimale dans un temps acceptable.
Dans la suite de ce chapitre on supposera que l’ensemble des variables X est composé de
deux types de variables Y et Z tel que X = Y∪Z. Les variables contenues dans Y sont des
variables qui appartiennent à la fonction objectif, tandis que les variables contenues dans Z
appartiennent aux contraintes mais pas à la fonction objectif.
Exemple 1 :
Ainsi, d’après le procédé de décomposition décrit, huit sous-problèmes basés sur cette
solution réalisable seront générés comme l’illustre la figure suivante :
Sur cette figure, nous observons un arbre de recherche dont le nœud racine est le problème
à minimiser. Les nœuds de la profondeur depth = 1 sont les sous-problèmes générés après
la décomposition du problème initial. Les nœuds de la profondeur depth = 2 sont les sous-
problèmes générés après la décomposition du sous-problème (a). Les sous-problèmes sous
lesquelles une croix (X) entourée d’un carré est représentée, sont des sous-problèmes qui
ne peuvent pas améliorer le upperB connue. Ainsi, ils ne seront pas visités. Par contre, les
sous-problèmes sous lesquelles une croix (X) entourée d’un cercle est représentée, sont ceux
qui sont susceptibles d’améliorer le upperB.
Il convient de noter que l’arbre de recherche n’est conçue d’avance. Les sous-problèmes
sont générés et résolus de façons récursive. Après la génération d’un sous problème, il est
résolu avant la génération du sous-problème suivant. Ainsi, pour notre exemple, les deux
premiers sous-problèmes générés sont les sous-problèmes (a) et (i). Il convient de noter
également que les sous-problèmes sont classés par niveaux en fonction du nombre de sous-
domaines lef ti dans le sous-problème. Chaque niveau est désigné par Lp où p représente le
nombre de sous-domaines lef ti dans le sous-problème.
1 v o i d basic_sandd ( I l o I n t A r r a y t , I l o I n t n , I l o I n t p , I l o I n t V a r A r r a y y , IloNumArray s o l u t i o n ,
I l o M o d e l model , IloNumExpr f ) {
2
3 /∗ ( 1 ) ∗/ i f ( n == p ) {
4 f o r ( i n t i = 0 ; i <n ; i ++)
5 /∗ ( 1 ) ∗/ t [ i ] = 0;
6
7 /∗ ( 2 ) ∗/ i f ( lower_Bound ( t ) >= upperB ) {
8 c o u t << " Lower ␣ bound ␣ s u p p e r i e u r "<< e n d l ;
9 /∗ ( 2 ) ∗/ }
10 else {
11 /∗ ( 3 ) ∗/ I l o C o n s t r a i n t A r r a y decompose_Constraint ( env ) ;
12 f o r ( I l o I n t i = 0 ; i <t . g e t S i z e ( ) ; i ++){
13 i f ( t [ i ] == 0 )
14 decompose_Constraint . add ( y [ i ] <= s o l u t i o n [ i ] ) ;
15 else
16 decompose_Constraint . add ( y [ i ] > s o l u t i o n [ i ] ) ;
17 }
18 /∗ ( 3 ) ∗/ decompose_Constraint . add ( f < upperB ) ;
19 /∗ ( 4 ) ∗/ model . add ( decompose_Constraint ) ;
20
21 IloCP cp ( model ) ;
22 /∗ ( 5 ) ∗/ cp . s e t P a r a m e t e r ( IloCP : : SearchType , IloCP : : D e p t h F i r s t ) ;
23 i f ( cp . s o l v e ( ) ) {
24 upperB = cp . getObjValue ( ) ;
25 c o u t << " o b j e c t i v e S p=" << cp . getObjValue ( ) <<e n d l ;
26 }
27 else {
précédant sous-problèmes.
Une autre faiblesse de l’ancienne version de l’algorithme S&D est de prouver que le upperB
connue est la solution optimale en raison du nombre exponentiel de sous-problèmes générés
qui est dû au nombre de variables apparaissant dans la fonction objectif. Pour palier à ces
faiblesses de l’ancienne version de l’algorithme S&D, nous proposons dans la section 2.3.2
une stratégie de regroupement de l’ensemble des sous-problèmes générés pour un niveau Lp
en un seul sous-problème.
L’autre approche que nous proposons est de regrouper l’ensemble des sous-problèmes
générés pour un niveau Lp donné en un seul sous-problème. Une fois qu’une solution réalisable
S est obtenue en résolvant le CSP du problème d’origine, nous passons à l’étape de la
décomposition de ce problème. Dans la version précédente de l’algorithme S&D, pour un
niveau Lp, Cnp sous-problèmes sont générés avec n =| Y | le nombre de variable contenue
dans la fonction objectif. Pour remplacer cet ensemble de sous-problèmes en un seul sous-
problème, nous formulons un ensemble de contraintes levelConstraint que nous rajoutons au
problème d’origine. Cet ensemble de contraintes stipule que le nombre de variables yi ∈ Y
dont leur domaine est lef ti doit être égale à p. Ceci permet de prendre en considération tous
les sous-problèmes du niveau Lp. Nous donnons plus de détail sur cet ensemble de contraintes
levelConstraint dans la section 2.3.3.
Ainsi, comme illustré à la figure 2.5, on peut remarquer que le nombre exponentiel de
sous-problèmes qui devrait être générés a été réduit à un nombre fini de sous-problèmes.
Nous somme donc passé de 2|Y | sous-problèmes à | Y | +1 sous-problèmes. On peut aussi
remarquer que le filtrage est beaucoup plus efficace avec cette stratégie, car considérer comme
un seul sous-problème une partie de l’espace de recherche ne sera pas parcourue plus d’une
fois. Il convient de remarquer également que le temps de décomposition pour un niveau Lp,
qui était égale à (Cnp - 1)*Td a été éliminé. Ainsi, pour tous les niveaux allant de p=0 à
Pp=|Y |
p=| Y |, le temps de décomposition éliminé est égale à : ( p=0 Cnp - | Y | - 1)*Td ou (2|Y | -
| Y | - 1)*Td.
" n’est pas une fonction récursive. De plus, l’ensemble des contraintes levelConstraint et le
tableau de variable binaire permettent de regroupé tous les sous-problèmes du niveau p en
un seul sous-problème.
1 v o i d grouped_sandd ( I n t n , I l o I n t p , I l o I n t V a r A r r a y y , I l o I n t A r r a y s o l u t i o n , I l o M o d e l model ,
IloNumExpr f ) {
2
3 /∗ ∗/ I l o C o n s t r a i n t A r r a y l e v e l _ C o n s t r a i n t ( env ) ;
4 I l o I n t V a r A r r a y t ( env , n , 0 , 1 ) ;
5 f o r ( I l o I n t i = 0 ; i <n ; i ++){
6 l e v e l _ C o n s t r a i n t . add ( I l o I f T h e n ( env , t [ i ] == 1 , y [ i ] <= s o l u t i o n [ i ] ) ) ;
7 l e v e l _ C o n s t r a i n t . add ( I l o I f T h e n ( env , t [ i ] == 0 , y [ i ] > s o l u t i o n [ i ] ) ) ;
8 }
9
10 /∗ ∗/ l e v e l _ C o n s t r a i n t . add ( IloSum ( t ) == p ) ;
11 model . add ( l e v e l _ C o n s t r a i n t ) ;
12 model . add ( f < upperB ) ;
13 IloCP cp ( model ) ;
14 cp . s e t P a r a m e t e r ( IloCP : : SearchType , IloCP : : D e p t h F i r s t ) ;
15 i f ( cp . s o l v e ( ) ) {
16 upperB = cp . getObjValue ( ) ;
17 c o u t << " o b j e c t i v e S p=" << cp . getObjValue ( ) <<e n d l ;
18 }
19 else {
20
21 c o u t << " Pas ␣ de ␣ s o l u t i o n ␣ " << e n d l ;
22 }
23 cp . end ( ) ;
24 model . remove ( l e v e l _ C o n s t r a i n t ) ;
25 l e v e l _ C o n s t r a i n t . end ( ) ;
26 }
Pour la phase de développement, nous avons utilisé un ordinateur portable de marque Le-
novo G500 avec les caractéristiques suivantes :
– Procésseur : Intel(R) Pentium(R) CPU 2.40GHz 2.40GHz 64 bit
– Mémoire RAM : 4 GB
Environnements logiciel :
1 void I l c C y c l e I : : post ( ) {
2 f o r ( i n t i = 0 ; i < _x_var . g e t S i z e ( ) ; i ++){
3 _x_var [ i ] . whenValue ( t h i s ) ;
4 }
5 }
Dans la fonction propagate, au niveau de la ligne 2, " _x_var " est un tableau de variable
qui représente l’ensemble des villes à visitées. L’instruction " IloCP cp = _x_var " permet
d’extraire le tableau de variables dans le moteur de résolution CP Optimizer. La première
boucle commençant à la ligne 3 permet de parcourir le tableau de variable pour déterminer
la dernière ville en cours de visite. Cependant, la condition de vérification commençant à la
ligne 4 vérifie si la ville i est la dernière ville qui vient d’être visitée. Si cela est le cas, un
tableau de variables " y " est introduit. Le tableau de variables " y " permet d’enregistrer la
liste des villes visitées dans l’ordre en partant de la ville i. Ensuite, une contrainte globale
" IlcAllDiff " est appliqué à cette liste de villes. Cette contrainte " IlcAllDiff " contraint le
tableau de variable à contenir des valeurs différentes. Ainsi, si en partant de la ville i, parmi
les (n - 1) prochaines villes à visitées, une ville est visité plus d’une fois, alors la contrainte
" IlcAllDiff(y) " est violée. Dans la fonction post, la boucle permet de déclencher la fonction
propagate à chaque fois qu’une ville est visitée.
1 ILCGOAL1( I n s t a n c a t e , I l c I n t V a r , x_var ) {
2 i f ( x_var . i s F i x e d ( ) ) r e t u r n 0 ;
3 I l c I n t v a l = x_var . getMin ( ) ;
4 r e t u r n I l c O r ( x_var == v a l , I lc An d ( x_var != v a l , t h i s ) ) ;
5 }
Ainsi, ces buts ont été utilisé pour implémenté le DFS, le " Basic S&D " et le " Grouped
S&D " en bas niveau. Pour, l’implémentation du " Basic S&D " et du " Grouped S&D " en
haut niveau, nous avons utilisés comme algorithme de base, l’algorithme DFS prédéfini dans
le moteur de résolution CP Optimizeur.
La figure 2.6 ci-dessous montre les courbes des solutions obtenus par chaque algorithme en
fonction du temps pour l’instance f tv70 du TSP qui comporte 71 variables dans sa fonction
objectif. Sur cette figure on remarque que la valeur de la première solution obtenu par les
trois algorithmes est 3346. A partir de cette valeur, on remarque une chute des courbes du
Basic S&D et du Grouped S&D. On peut aussi remarquer qu’en 1000 secondes, les courbes
du Basic S&D et du Grouped S&D sont plus proche de la solution optimale qui est égale à
1950. Les courbes du Basic S&D et Grouped S&D sont confondus car la deuxième solution
a été trouvée en résolvant le premier sous-problème généré qui correspond au niveau L71 .
Ce niveau, ne comportant qu’un seul sous-problème pour les deux algorithmes, alors le
temps nécessaire pour la résolution de ce sous-problème est sensiblement égale pour les deux
algorithmes S&D.
Figure 2.6 – Courbes des solutions obtenus par le DFS, le Basic S&D et le Grouped S&D
en fonction du temps pour l’instance f tv70 du TSP.
Le tableau 2.2 ci-dessous présente les résultats des temps d’exécution en seconde pour
le TSP en utilisant le DFS prédéfini dans CP Optimizer, le Basic S&D et le Grouped S&D
implémentés en haut niveau. La colonne " Nom " représente le nom des instances du TSP, la
colonne " n " représente le nombre variable contenue dans la fonction objective et la colonne
" opt " représente la valeur de la solution optimale pour chaque instance. Pour chaque algo-
rithme, la colonne " Sol1 " représente la valeur de la première solution trouver. Cette solution
est la même pour tous les trois algorithmes, car les algorithmes Basic S&D et Grouped S&D
utilise la première solution fournie par le DFS pour effectué la décomposition. Les colonnes
" Sol2 " et " Sold " représentent respectivement la deuxième solution trouver et la dernière
solution trouver. La dernière solution correspond en fait à la meilleur solution trouver en
1000 seconds. Pour chaque solution trouvée, les colonnes " val " et " ts " représentent la
valeur de la solution et le temps d’exécution en seconde nécessaire pour obtenir la solution.
Cependant, pour le Basic S&D et le Grouped S&D le niveau à la quel la deuxième solution
a été trouvé est représenté par " (Lp ) " avec p le nombre de sous-domaine lef ti dans le
sous-problème. Les " - " notifient qu’aucune solution n’a été trouvée en 1000 secondes.
Pour effectuer une comparaison entre les trois algorithmes, nous passerons par deux
étapes. En premier lieu, nous comparons pour chaque algorithme les valeurs val de la solution
Sol2 et les temps d’exécutions ts nécessaire pour trouver la solution Sol2 . Ainsi, on peut
remarqué l’écart entre la valeur de la deuxième solution trouvée par le DFS et celle trouvée
par les algorithmes Basic S&D et Grouped S&D par rapport au temps, pour la majorité des
instances. On remarque donc que les algorithmes S&D trouvent une solution plus proche de
la solution optimale. Le rapport de différence entre le S&D Basic et le Grouped S&D se situe
au niveau du temps ts où l’on remarque un léger avantage du Grouped S&D sur le Basic
S&D. En second lieu, nous comparons pour chaque algorithme le valeur val de la meilleur
solution trouvée en 1000 secondes. On peut toujours remarqué un écart entre ces valeurs.
Cela nous permet de conclure que le Grouped S&D est plus efficace que le DFS et le Basic
S&D.
Page 34/37
f tv55 56 1608 2551 7.5 s 2543 12.3 s 2351 914.5 s 2288(L56 ) 7.8 s 1938 317.8 s 2288 8.1 s 1938 309.5 s
f tv64 65 1839 2621 7.4 s 2574 8.3 s 2443 73.2 s 2408(L64 ) 13.2 s 2371 991.5 s 2408 12.9 s 2371 976.2 s
f tv70 71 1950 3346 11.2 s 3293 22.4 s 3039 804.3 s 2841(L71 ) 13.6 s 2554 194.3 s 2841 12.7 s 2554 197.9 s
Tableau 2.2 – Temps d’exécution en seconde pour huit instances du TSP en utilisant le DFS, le Basic S&D et le Grouped S&D
CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE
CHAPITRE 2. L’ALGORITHME SOLVE AND DECOMPOSE
2.5 Conclusion
Dans ce chapitre, une description de l’algorithme S&D a été présentée et des améliorations
ont été apportées à cette algorithme. Des implémentations ont ensuite été effectuées pour les
deux versions du S&D ainsi que pour le DFS et la contrainte de cycle pour le TSP. Enfin des
tests effectués sur des instances du TSP ont permis d’évaluer l’efficacité de la stratégie de
décomposition et du regroupement des sous-problèmes. Nous avons ensuite remarqué d’après
les résultats obtenus que le regroupement des sous-problèmes d’un niveau est très efficace en
matière de résoudre les sous-problèmes plus rapidement et de trouver une solution beaucoup
plus proche de la solution optimale dans un temps rapide.
CONCLUSION ET PERSPECTIVES
Dans ce mémoire, nous avons donné les définitions de bases et quelques exemples des
problèmes de satisfaction de contraintes et des problèmes d’optimisation combinatoire sous
contraintes. Nous avons également présenté des méthodes de résolution exactes pour résoudre
les problèmes d’optimisation. Ensuite, nous avons présenté l’algorithme Solve and Decompose
qui est une stratégie de recherche combinée à des méthodes de résolution exactes pour trouver
la solution optimale ou un solution plus proche de de la solution optimale dans un temps
rapide. Notre but a été donc d’améliorer cette algorithme afin qu’il soit plus efficace.
Pour aboutir aux résultats escomptés, nous sommes passés par plusieurs phases. La
première phase a été, d’apprendre à maitriser l’outil de modélisation des problèmes d’opti-
misation IBM ILOG Concert Technology et le moteur de programmation par contarinte
CP Optimizer. Après cela, nous sommes passés à la phase d’implémentation et ensuite à la
phase des tests pour évaluer le nouvel l’algorithme. Les résultats que nous avons obtenus nous
ont permis de conclure que le nouvel algorithme est plus efficace que l’ancien algorithme. Ce-
pendant, le principe du nouvel algorithme étant de regroupé l’ensemble des sous-problèmes
d’un niveau en un seul sous-problème, nous pensons qu’il peut être possible de regroupé tous
les sous-problèmes en un seul sous-problème. Ainsi, le principe de décomposition sera géré
de façon interne et non de façon externe. Cela signifie qu’une fois que la première solution
est obtenue, la décomposition ne sera plus physique, mais plutôt logique.
Ce travail nous a été très instructif du point de vue des connaissances acquises, d’une prise
de conscience sur nos forces et nos faiblesses et des améliorations que nous pouvont apportés
à ce travail. Il nous a procuré une opportunité de découvrir le monde de la programmation
par contrainte et de l’optimisation. Nous sommes satisfaits du travail accompli malgré le
temps qui était insuffisant pour effectué des tests sur d’autre type de problème.
BIBLIOGRAPHIE