colonies d’abeilles et sat parall`eleszczepanski/res/colonies d... · en jeu autant de...

Colonies d’abeilles et SAT parallele

MEMOIRE

presente le 3 juillet 2014

pour l’obtention du

Master Deuxieme Annee de l’Universite d’Artois

Specialite Informatique

par

Nicolas SZCZEPANSKI

Encadrants : Gilles Audemard Professeur a l’Universite d’ArtoisJean-Marie Lagniez Chercheur Post-Doctorant au CRILLaurent Simon Professeur a l’Universite de BordeauxSebastien Tabary Maıtre de conference a l’Universite d’Artois

CENTRE DE RECHERCHE EN INFORMATIQUE DE LENS – CNRS UMR 8188

Universite d’Artois, rue Jean Souvraz, S.P. 18 F-62307, Lens Cedex France

Secretariat : Tel.: +33 (0)3 21 79 17 23 – Fax : +33 (0)3 21 79 17 70

http://www.cril.univ-artois.fr

Mise en page avec memcril (B. Mazure, CRIL) et thloria (D. Roegel, LORIA).

Table des matières

Table des figures iv

Liste des Algorithmes vi

Remerciements 2

Introduction générale

État de l’art

Chapitre 1 Le probleme SAT

La logique propositionnelle 6

1.1 Syntaxe de la logique propositionnelle . . . . . . . . . . . . . . . . . . . . . . . . . 6

1.1.1 Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

1.1.2 Formules bien formées . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.2 Sémantique de la logique propositionnelle . . . . . . . . . . . . . . . . . . . . . . 7

1.2.1 Sémantique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.2.2 Définitions et théorèmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.3 Formes normales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.4 Le problème SAT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

i

Table des matières

Chapitre 2 SAT en parallèle 10

2.1 Modèles parallèles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.1.1 Préliminaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.1.2 Modèles d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

2.1.3 Modèles de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2.2 Résoudre SAT en parallèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2.2.1 Le modèle concurrentiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2.2.2 Les solveurs concurrentiels . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.2.3 Le solveur PENELOPE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.2.4 Le modèle collaboratif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.2.5 Le chemin de guidage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

2.2.6 Le chemin de guidage : le rééquilibrage des charges . . . . . . . . . . . . . 18

2.2.7 Les solveurs de type chemin de guidage . . . . . . . . . . . . . . . . . . . 21

2.3 Cube And Conquer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2.3.1 Algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.3.2 L’heuristique de coupure . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

2.3.3 L’heuristique de choix de variables . . . . . . . . . . . . . . . . . . . . . . 24

2.3.4 La résolution des cubes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

2.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

Chapitre 3 Les problèmes de bandits 26

3.1 Le problème de bandits classique . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.1.1 Multi-armed bandit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.1.2 La stratégie d’allocation et regret . . . . . . . . . . . . . . . . . . . . . . . 27

3.2 La stratégie UCB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

3.2.1 Définition et exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

3.2.2 Exemple d’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

3.3 L’algorithme UCT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

3.3.1 Squelette de l’algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

3.3.2 Explication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

3.3.3 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

Contribution

ii

Chapitre 4 Une méta-heuristique des colonies d’abeilles butineuses pour SAT 36

4.1 Une méta-heuristique massivement parallélisable . . . . . . . . . . . . . . . . . . . 37

4.1.1 Le choix du comportement à adopter . . . . . . . . . . . . . . . . . . . . . 37

4.1.2 La communication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

4.1.3 Hiérarchie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

4.2 Déroulement de l’algorithme mémétique . . . . . . . . . . . . . . . . . . . . . . . 39

4.3 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

Chapitre 5 Une adaptation d’UCT pour SAT : l’algorithme SCOUT 41

5.1 Le choix d’UCT pour générer des cubes . . . . . . . . . . . . . . . . . . . . . . . . 42

5.2 Description de l’algorithme SCOUT . . . . . . . . . . . . . . . . . . . . . . . . . . 42

5.2.1 La descente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

5.2.2 La descente : Les valeurs UCB . . . . . . . . . . . . . . . . . . . . . . . . . 45

5.2.3 La descente : la création de nouveaux fils . . . . . . . . . . . . . . . . . . . 46

5.2.4 La descente : les conflits et littéraux déjà affectés . . . . . . . . . . . . . . . 47

5.2.5 La sélection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

5.2.6 La simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

5.2.7 La remontée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

5.3 La récupération des cubes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

5.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

Chapitre 6 Résultats 53

6.1 Le programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

6.2 Expérience sur les variables des cubes . . . . . . . . . . . . . . . . . . . . . . . . . 54

6.3 Expérimentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

6.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

Conclusion 60

Bibliographie 62

iii

Table des figures

1.1 Connecteurs logiques usuels de la logique propositionnelle. . . . . . . . . . . . . . . . . 7

2.1 Schémas de processeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.2 Parallélisme concurrentiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.3 Diagramme des clauses apprises dans PENELOPE . . . . . . . . . . . . . . . . . . . . . 172.4 Parallélisme « diviser pour régner » . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172.5 Chemin de guidage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182.6 rééquilibrage des charges : état initial, F et G travaillent. . . . . . . . . . . . . . . . . . 192.7 rééquilibrage des charges : F a terminé son sous-arbre, G travaille. . . . . . . . . . . . . 192.8 rééquilibrage des charges : F informe le maître, G travaille. . . . . . . . . . . . . . . . . 192.9 rééquilibrage des charges : F récupère un chemin de guidage depuis le maître. . . . . . . 202.10 rééquilibrage des charges : le maître n’a plus de chemin à fournir, il stoppe G . . . . . . 202.11 rééquilibrage des charges : G envoie son chemin de guidage . . . . . . . . . . . . . . . . 202.12 rééquilibrage des charges : les chemins de guidage sont rééquilibrés . . . . . . . . . . . 212.13 Cube And Conquer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

3.1 Des bandits manchots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273.2 Étape de l’algorithme UCT. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

4.1 Hiérarchie des tâches de chaque solveur SAT inspirée des colonies d’abeilles butineuses . 384.2 Déroulement de l’algorithme mémétique . . . . . . . . . . . . . . . . . . . . . . . . . . 40

5.1 Structure des nœuds dans notre algorithme SCOUT. . . . . . . . . . . . . . . . . . . . . 435.2 La descente dans notre algorithme SCOUT . . . . . . . . . . . . . . . . . . . . . . . . . 445.3 Calcul des valeurs UCB dans SCOUT . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455.4 Conflit ou littéral déjà affecté à une valeur opposée lors de la descente dans notre algo-

rithme SCOUT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475.5 Littéral déjà affecté lors de la descente dans notre algorithme SCOUT . . . . . . . . . . 485.6 La sélection dans notre algorithme SCOUT . . . . . . . . . . . . . . . . . . . . . . . . 495.7 La remontée dans notre algorithme SCOUT . . . . . . . . . . . . . . . . . . . . . . . . 505.8 Affinage de l’arbre de SCOUT par un algorithme de colonie d’abeilles . . . . . . . . . . 51

6.1 Fichier .cubes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546.2 Nombre de variables dans les cubes (partie 1) . . . . . . . . . . . . . . . . . . . . . . . 556.3 Nombre de variables dans les cubes (partie 2) . . . . . . . . . . . . . . . . . . . . . . . 566.4 Nombre de variables dans les cubes (partie 3) : UTI-20-5p1 : 1195016 clauses et 225926

variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566.5 Information sur la création des cubes. . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

iv

6.6 Résultat : Informations sur tous les cubes. . . . . . . . . . . . . . . . . . . . . . . . . . 576.7 Information sur les cubes uniquement satisfiables. . . . . . . . . . . . . . . . . . . . . . 586.8 Informations sur le meilleur cube satisfiable uniquement. . . . . . . . . . . . . . . . . . 586.9 Numéro des cubes satisfiables des instances en possédant. . . . . . . . . . . . . . . . . . 59

v

Liste des Algorithmes

1 CC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2 UCT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313 descenteSelectionUCT(R) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314 remontéeUCT(P,R) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

5 descenteScoutV1(R) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436 descenteScoutV2(R) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477 récupCube(R) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

vi

LISTE DES ALGORITHMES

1

Remerciements

En premier lieu, je tiens à remercier Eric Grégoire de m’avoir permis d’effectuer ce stage au sein duCRIL.

Je remercie aussi mes encadrants Gilles Audemard, Jean-Marie Lagniez, Laurent Simon et SébastienTabary pour leurs nombreuses relectures ainsi que leurs précieux conseilles.

Je tiens également à remercier mes camarades de promotion pour leur sympathie et pour leur convi-vialité.

Ma famille et plus particulièrement, Élodie, pour ces nombreuses corrections.

2


LE PROBLÈME DE SATISFAISABILITÉ BOOLÉENNE, abrégé par SAT, est un problème de décision vi-sant à savoir s’il existe un assignement qui satisfait une formule de la logique propositionnelle, ou

qui détermine qu’un tel assignement n’existe pas. Nous classons respectivement ces formules commesatifiables ou insatifiables. SAT est un problème théoriquement important car il a été le premier problèmeà être prouvé NP-Complet [Coo71]. Malgré une complexité théorique difficile, les solveurs SAT mo-dernes sont devenus étonnamment efficaces et permettent de résoudre de nombreux problèmes venantd’applications industrielles (planification, vérification formelle, bio-informatique, etc.). Deux raisons es-sentielles peuvent justifier cette performance. La première est algorithmique et, est due à l’envol dessolveurs SAT modernes de type CDCL (apprentissage, VSIDS, watched literal, ...). Tandis que la secondeest technologique et, est intrinsèquement liée à un doublement des fréquences de fonctionnement desmicroprocesseurs qui a lieu tous les dix-huit mois (ce phénomène est nommé la loi de Moore). Ainsi,jusqu’à 2005, les solveurs SAT modernes pouvaient profiter de ce gain technologique afin de résoudre desproblèmes de plus en plus difficiles. Cependant, à l’heure actuelle, à cause de l’échauffement importantdes microprocesseurs à des fréquences avoisinant les 4 GHz, il n’a plus été envisageable d’accroître lesperformances des solveurs de cette manière. En effet, les constructeurs ont donc décidé d’opter pour unemultiplication des unités de calcul afin de toujours doubler la puissance des ordinateurs. De ce fait, leproblème SAT doit être repensé par les développeurs de manière à s’adapter à un modèle de programma-tion parallèle.

Le problème SAT a longtemps été pensé et codé sur un modèle séquentiel. Une adaptation consé-quente est donc nécessaire afin de pouvoir bénéficier du parallélisme. A ce jour, deux méthodes per-mettent la résolution d’un problème SAT en parallèle : une méthode collaborative et une autre concurren-tielle exposées au chapitre 2. Ces méthodes peuvent rencontrer deux problèmes technologiques freinantle calcul. Le premier, appelé le goulot d’étranglement de Von Neumann, est une surcharge du bus entreles processeurs et la mémoire. Le deuxième est un coût de communication dans les algorithmes parallèlespouvant être trop important. Les tentatives de parallélisation pour SAT ont en majeure partie échouées.En effet, les approches parallèles actuelles limitent au maximum le partage des informations et n’arriventpas à suivre entièrement la loi de Moore comme il était possible dans le passé. De plus, les méthodesne passent pas à l’échelle : le fait d’augmenter le nombre de cœurs dégrade les performances [ABK13].Actuellement, un des meilleurs solveur parallèle est un simple outil lançant en concurrence les meilleurssolveurs de l’état de l’art [Rou12].

Dans un but massivement parallèle, nous nous inspirons du comportement de la nature (essaimd’abeilles, colonie de fourmis, génétique, ...) afin de définir un nouveau schéma de parallélisation. Eneffet, dans la nature, nous retrouvons beaucoup de situations où des tâches doivent être réalisées en col-laboration. Par exemple, la coopération des fourmis via des phéromones leur permet de pouvoir faire destâches complexes comme la recherche de nourriture à plusieurs endroits distincts (tâche qui ne pourraitpas être réalisée pas une seule fourmi). Ainsi, ces fourmis sont capables d’obtenir rapidement une bonne

3


solution sur le problème du voyageur de commerce [DG97]. Ces algorithmes, nommés algorithmes mé-métiques, font partie des d’algorithmes d’optimisations (algorithme de colonie de fourmis, algorithmed’essaim d’abeilles, ...). Grâce à une adaptation face au problème concerné, ces algorithmes proposentune série de concepts pouvant être exploités afin de définir des algorithmes massivement parallèles. Dansce manuscrit, nous proposons d’utiliser les algorithmes de colonies d’abeilles pour résoudre SAT sur unearchitecture massivement parallèle.

Tout d’abord, après une présentation de la logique propositionnelle, nous exposons le problème SAT

accompagné d’un exemple (chapitre 1). Puis, nous expliquons les notions de la parallélisation pour expo-ser un état de l’art des solveurs SAT parallèles. Nous distinguons alors les deux méthodes générales pourparalléliser le problème SAT : le modèle concurrentiel et modèle collaboratif (chapitre 2). Nous abordonsensuite des notions qui sont essentielles dans nos travaux : le dilemme exploitation/exploration ainsi quel’algorithme UCB (chapitre 3).

Nos contributions commencent par une subtile adaptation de l’algorithme des colonies d’abeilles bu-tineuses pour une parallélisation massive du problème SAT. Ce modèle nécessite la mise en place de nom-breux concepts tournant autour de l’organisation des abeilles butineuses. En effet, dans leur recherchede nectar, les abeilles ont chacune leurs propres rôles à exécuter (abeilles scouts, abeilles butineuses,abeilles recrues). De plus, ces abeilles sont de deux types différents : celles sans mémoire et celles enpossédant (abeilles expérimentées). Les fonctionnalités nombreuses des abeilles butineuses mettent doncen jeu autant de méta-heuristiques à adapter dans notre contexte. Ce modèle est exposé dans le chapitre4, il définit chaque rôle distinct des abeilles, et chaque liaison entres elles dans le cadre d’une parallélisa-tion massive du problème SAT. Dû aux multiples tâches que représentent ce modèle, nous nous sommesdans un premier temps concentré sur la création d’une abeille de type scout.

Les abeilles scouts ont pour fonction d’explorer les alentours afin de trouver des fleurs possédantun maximum de nectars. Dans le contexte de SAT, nous avons défini qu’il s’agit d’avoir une méthodegénérant des cubes. Nous entendons par un cube, une interprétation partielle en SAT : une conjonctionde littéraux. Sachant que, par la suite, d’autres abeilles butineuses pourront toujours affiner ces cubes vianotre modèle de colonie d’abeilles. Notre deuxième contribution exposée dans le chapitre 5 a donc pourobjectif de créer un ensemble de cubes : nous avons nommé cette méthode SCOUT. De plus, nous sou-haitons ordonner les cubes du meilleur au moins bon. Néanmoins, estimer la qualité d’une interprétationpartielle est aussi difficile que de résoudre l’instance initiale.

À l’intérieur du chapitre 2, nous avons choisi de décrire en détail la méthode Cube And Conquer (CC)[HKWB12] pour une bonne raison. Il se trouve que celle-ci possède un point commun avec nos travaux :elle effectue aussi une division en millions de cubes. De plus, dans l’optique de choisir les meilleurscubes dans un arbre de recherche, nous avons été confrontés au dilemme exploitation/exploration : faut-il exploiter un cube déjà considéré comme bon en lui rajoutant des littéraux ou retenter notre chance avecun nouveau cube. Récemment, la naissance d’un algorithme pour les jeux à deux joueurs nommé UCT

traite ce problème : exploiter un état de la partie qui semble être bon, ou explorer d’autres états moinsbons. Nous avons donc adapté l’algorithme UCT afin de générer des cubes dans notre méthode SCOUT.

Avant de conclure, nous exposons les résultats apportés par quelques expérimentations afin d’étudierla qualité des cubes générés par notre méthode SCOUT. La méthode SCOUT n’est qu’une première briqueutilisée dans notre modèle de colonie d’abeilles pour SAT dans un but massivement parallèle. Une thèsesuivant ces travaux aura pour acquis le travail fourni pendant ce stage.

4

État de l’art

5

Chapitre 1

Le probleme SATLa logique propositionnelle

Sommaire

1.1 Syntaxe de la logique propositionnelle . . . . . . . . . . . . . . . . . . . . . . 6

1.1.1 Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

1.1.2 Formules bien formées . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.2 Sémantique de la logique propositionnelle . . . . . . . . . . . . . . . . . . . . 7

1.2.1 Sémantique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.2.2 Définitions et théorèmes . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.3 Formes normales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.4 Le problème SAT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

CE CHAPITRE a pour objectif de présenter brièvement le problème SAT pour boolean SATisfiability

problem d’une formule propositionnelle. Nous rappelons tout d’abord la syntaxe puis la sémantiquede la logique propositionnelle. Après quelques définitions et propriétés sur cette logique, nous exposeronsce qu’est le problème SAT en l’accompagnant d’un exemple. Ce chapitre, représentant des notions de baseconnues dans la littérature, est destiné aux lecteurs ne connaissant pas le problème SAT.

1.1 Syntaxe de la logique propositionnelle

1.1.1 Syntaxe

Définition (Vocabulaire de la logique propositionnelle). La base de la syntaxe du calcul des propositionssont les variables propositionnelles ou propositions atomiques, notées p, q, x, ... qui constituent générale-ment un ensemble infini dénombrable. Cette syntaxe contient aussi des symboles de ponctuation qui sontsouvent notées "(", ")", "[" et "]". De plus, les deux constantes propositionnelles ⊥ et ⊤ représentent res-pectivement le "faux" et le "vrai". Pour finir, elle est constituée de l’ensemble des connecteurs logiquesusuels, présentés dans la figure 1.1.

6

1.2. Sémantique de la logique propositionnelle

Nom Négation Conjonction Disjonction Implication Equivalence Ou exclusifArité Unaire Binaire Binaire Binaire Binaire Binaire

Symbole ¬ ∧ ∨ ⇒ ⇔ ⊕

FIGURE 1.1 – Connecteurs logiques usuels de la logique propositionnelle.

1.1.2 Formules bien formées

La syntaxe permet de distinguer les formules bien formées parmi les assemblages quelconques desymboles.

Définition (Formules de la logique propositionnelle). Les phrases du langage de la logique proposition-nelle sont obtenues récursivement à partir des propositions et d’un ensemble de règles syntaxiques. Cesphrases sont appelées formules :

− Toute proposition x est une formule (règle de base) ;

− Si F et G sont des formules, alors ¬F , (F ∧ G), (F ∨ G), (F ⇒ G), (F ⇔ G) et (F ⊕ G) sont desformules (règle d’induction) ;

− Une formule s’obtient uniquement à partir des règles de base et d’induction (règle de fermeture).

1.2 Sémantique de la logique propositionnelle

1.2.1 Sémantique

La sémantique de la logique propositionnelle est compositionnelle : c’est-à-dire que la significationd’une formule sera en fonction de celle de ses constituants. La valeur de vérité d’une formule dépendrauniquement de sa composition.

Définition (Sémantique de la logique propositionnelle).

− Chaque variable propositionnelle (x1, x2, ..., xn) est interprétée comme vraie ou fausse ;

− si F est une formule, alors ¬F est vraie si et seulement si F est fausse ;

− si F et G sont des formules, alors :

− (F ∧ G) est vraie si et seulement si F et G sont vraies ;

− (F ∨ G) est vraie si et seulement si F ou G est vraie ;

− (F ⇒ G) est vraie si et seulement si F est fausse ou G est vraie ;

− (F ⇔ G) est vraie si et seulement si F et G sont soit toutes deux vraies, soit toutes deux fausses ;

− (F ⊕ G) est vraie si et seulement si seul F ou seul G est vraie (pas les deux en même temps).

1.2.2 Définitions et théorèmes

Définition (Interprétation). Une interprétation est une fonction qui associe à toute variable proposition-nelle une valeur de vérité. Cette fonction, dont le domaine est l’ensemble des propositions, est prolongéeà l’ensemble des formules au moyen des règles de la sémantique. Le prolongement correspondant estencore appelé interprétation.

7

Chapitre 1. Le probleme SAT La logique propositionnelle

Définition (Modèle). Un modèle d’une formule est une interprétation de cette formule qui la vérifie,c’est-à-dire, qui lui associe la valeur vraie.

Définition (Falsifie). Par opposition, on dit qu’une interprétation falsifie une formule lorsqu’elle lui as-socie la valeur faux.

Définition (Satisfiable, Insatisfiable). On dit qu’une formule est satisfiable ou consistante si et seule-ment si il existe au moins un modèle qui la vérifie, sinon elle est insatisfiable.

Définition (Conséquence logique). Si tout modèle d’une formule F est modèle d’une formule G alors Gest une conséquence logique de F , noté F |= G.

Définition (Logiquement équivalentes). Les formules F et Gsont logiquement équivalentes, si F |=G et G |= F , noté F ≡ G.

Définition (Formule valide, Tautologie). Lorsque la formule F est vérifiée par toutes ses interpréta-tions, F est une tautologie. On dit aussi que F est valide et on notera cette assertion � F .

Définition (Théorème de la déduction). Soit F et G deux formules propositionnelles, on a F |= G siet seulement si F ∧ ¬G est une formule insatisfiable.

Exemple. Voici quelques tautologie de la logique propositionnelle :

Nom ExpressionsDéfinition de⇒ F ⇒ G ⇔ ¬ F ∨ GDéfinition de⇔ (F ⇔ G)⇔ ((F ⇒ G) ∧ (G ⇒ F))⇔ ((¬F ∨ G) ∧ (¬G ∨ F))Modus ponens ((F ⇒ G) ∧ F)⇒ GModus tollens ((F ⇒ G) ∧ ¬G)⇒ ¬FContraposition (F ⇒ G)⇔ (¬G ⇒ ¬F)

1.3 Formes normales

Définition (Littéral, Clause, Terme).

− Un littéral est une variable propositionnelle ou bien sa négation : x et ¬x sont des littéraux ;

− Une clause est une disjonction de littéraux : une formule de la forme (x1∨x2∨ ...∨xn) où chaquexn représente un littéral ;

− Un terme (ou cube) est une conjonction de littéraux : une formule de la forme (x1 ∧ x2 ∧ ... ∧ xn)où chaque xn représente un littéral.

Définition (NNF, DNF, CNF). Nous distinguons trois formes normales particulières :

− Une formule propositionnelle est dite sous forme normale négative (NNF pour Negative Normal

Form) si elle est exclusivement constituée de conjonctions, de disjonctions et de littéraux ;

− Une formule propositionnelle est dite sous forme normale disjonctive (DNF pour Disjonctive Nor-

mal Form) si c’est une disjonction de termes ;

− Une formule propositionnelle est dite sous forme normale conjonctive (CNF pour Conjonctive Nor-

mal Form) si c’est une conjonction de clauses.

8

1.4. Le problème SAT

Pour toute formule de la logique propositionnelle, il existe une formule équivalente sous forme normale.

1.4 Le problème SAT

Définition (Le problème SAT). Le problème SAT est le problème de décision qui consiste à savoir si uneformule sous forme normale conjonctive possède ou pas un modèle (si elle est satisfiable).

Le problème SAT occupe un rôle très important en théorie de la complexité puisqu’il représente leproblème NP-Complet de référence [Coo71]. C’est donc un problème théoriquement difficile pour un or-dinateur, mais il possède des méthodes de résolution très efficaces en pratique. On peut citer les solveursSAT modernes de type CDCL qui sont une grande avancée dans l’histoire de ces solveurs. De nombreuxproblèmes s’y rapportent naturellement ou le contiennent. Grâce à la performance des solveurs SAT mo-derne, certains problèmes préfèrent être traduits en SAT (CNF) afin de bénéficier d’une efficacité plusaccrue comparée à leurs propres méthodes de résolutions. Le problème SAT contient de nombreuses ap-plications en planification classique (ordonnancement de tâches, robot sur mars, ...), vérification (model

checking, ...), diagnostic (d’erreurs dans les circuits électroniques, ...), bio-informatique, CSP, etc. À pré-sent, nous allons exposer un petit exemple de traduction d’un problème CSP en SAT.

Exemple. Soit un petit problème ne contenant que deux variables x et y, avec une seule contrainte :x + y = 3. Ces deux variables ont respectivement les domaines suivants : {1, 2, 3} et {0, 1, 4}. Le pro-blème consiste à savoir comment attribuer les variables sur leurs domaines respectifs tout en respectantla contrainte. Sachant qu’il existe des méthodes de résolutions propres à CSP, nous choisissons de l’en-coder en CNF afin de comprendre le mécanisme de SAT. Il existe plusieurs encodages possibles, nouschoisissons l’encodage direct. Tout d’abord, nous encodons les variables et leurs domaines en clauses,pour cela, nous aurons de nouvelles variables propositionnelles : xi et yi correspond respectivement àx = i et y = i.

− x1 ∨ x2 ∨ x3 représente le domaine de x ;

− ¬x1 ∨ ¬x2 la variable x ne peut pas prendre pour valeur en même temps 1 et 2 ;



− y0 ∨ y1 ∨ y4 représente le domaine de y ;

− ¬y0 ∨ ¬y1 la variable y ne peut pas prendre pour valeur en même temps 0 et 1 ;

− ¬y0 ∨ ¬y4 la variable y ne peut pas prendre pour valeur en même temps 0 et 4 ;

− ¬y1 ∨ ¬y4 la variable y ne peut pas prendre pour valeur en même temps 1 et 4.

Puis nous codons les couples de valeurs x et y impossibles à cause de la contrainte :¬x1∨¬y0,¬x1∨¬y1,¬x1∨¬y4, ¬x2∨¬y0, ¬x2∨¬y4, ¬x3∨¬y1, ¬x3∨¬y4. Toutes ces clauses forment une CNF. Un solveurSAT peut donc trouver un modèle comme : x2 = ⊤, y1 = ⊤ et le reste des variables propositionnelles àfaux. La solution associée en CSP est x = 2 et y = 1.

9

Chapitre 2

SAT en parallèle

Sommaire

2.1 Modèles parallèles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.1.1 Préliminaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.1.2 Modèles d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

2.1.3 Modèles de programmation . . . . . . . . . . . . . . . . . . . . . . . . . 14

2.2 Résoudre SAT en parallèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2.2.1 Le modèle concurrentiel . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2.2.2 Les solveurs concurrentiels . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.2.3 Le solveur PENELOPE . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.2.4 Le modèle collaboratif . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.2.5 Le chemin de guidage . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

2.2.6 Le chemin de guidage : le rééquilibrage des charges . . . . . . . . . . . . 18

2.2.7 Les solveurs de type chemin de guidage . . . . . . . . . . . . . . . . . . 21

2.3 Cube And Conquer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2.3.1 Algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.3.2 L’heuristique de coupure . . . . . . . . . . . . . . . . . . . . . . . . . . 23

2.3.3 L’heuristique de choix de variables . . . . . . . . . . . . . . . . . . . . . 24

2.3.4 La résolution des cubes . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

2.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

LONGTEMPS étudié dans un contexte séquentiel pour ses nombreuses applications industrielles (plani-fication, vérification formelle, bio-informatique, etc.), le problème SAT a fait éclore des algorithmes

efficaces et puissants qui s’expliquent à la fois par l’envol des solveurs SAT modernes (apprentissage,VSIDS, watched literal) et l’accroissement de la puissance de calcul. Ainsi, les solveurs SAT modernespermettent de résoudre des problèmes considérables contenant des millions de variables et de clauses.Cependant, de nombreuses instances restent encore inabordables dues à leur immense dimension et diffi-culté structurelle. Par ces complications, la parallélisation des algorithmes de résolution pour SAT semblenécessaire. Davantage par le fait qu’actuellement la puissance d’un ordinateur ne se traduit plus par uneamplification des fréquences du microprocesseur mais par l’augmentation du nombre de cœurs au seinde celui-ci. Néanmoins, la parallélisation d’un problème NP-Complet est une tâche ardue, l’efficacitéqui en résulte reste atténuée sur de nombreux cœurs.

10

2.1. Modèles parallèles

Au préalable, afin de comprendre cette accommodation, nous allons présenter les triviales notionsde la parallélisation ainsi que ses propres modèles d’exécution et de programmation. Cela nous serviraà appréhender les deux aspects distincts de la parallélisation du problème SAT : à savoir les méthodesde types « diviser pour régner » dites collaboratives et, à l’opposé des méthodes concurrentielles. Aprèsavoir relaté un historique partiel des solveurs représentant ces deux approches, nous présenterons endétail deux techniques se basant sur l’approche collaborative : le chemin de guidage (Guiding path) ainsique la méthode originale Cube And Conquer. En conclusion, nous discuterons du sujet de ce manuscritainsi que la voie choisie pour élaborer notre tâche, à savoir, mettre en œuvre un modèle permettant larésolution du problème SAT à l’aide des algorithmes de colonies d’abeilles dans un but massivementparallèle.

2.1 Modèles parallèles

Cœur de calcul

Mémoire cache L1

Mémoire cache L2

PROCESSEUR MONO-CŒUR

L2 partagée

PROCESSEUR MULTI-CŒUR

Cœur 1 Cœur 2 Cœur 3 Cœur 4

L1 dédiée L1 dédiée L1 dédiée L1 dédiée

FIGURE 2.1 – Schémas de processeurs

Depuis l’invention du premier microprocesseur (intel 4004) en 1971, Gordon Moore observe en 1975que le nombre de transistors des microprocesseurs sur une puce de silicium se réplique tous les deux ans.Cette observation appelée loi de Moore n’est pas une loi physique mais une extrapolation empirique quis’est révélée étonnamment fidèle pour le moment, elle s’est traduite par une augmentation des fréquencesde fonctionnement des microprocesseurs. Mais depuis environ 2005, à cause de l’échauffement impor-tant des microprocesseurs à des fréquences avoisinant les 4 GHz, il n’a plus été envisageable pour lesentreprises de les accroître. En contrepartie, il est aujourd’hui possible d’ajouter plusieurs cœurs de cal-cul au sein du même microprocesseur (figure 2.1). De cette manière, les industriels annoncent toujoursdoubler la puissance de leur microprocesseur pour ainsi honorer la loi de Moore. Néanmoins, les déve-loppeurs ne voient pas ce gain directement, et doivent s’apprivoiser à un modèle de programmation ditalors parallèle. Une contrainte embarrassante car tous les algorithmes voulant bénéficier du multi-cœurdoivent être repensés. La loi de Moore ne sera probablement plus exacte dans le futur, et commencedéjà à ne plus l’être, certaines entreprises disent ne pas la respecter pour des raisons énergétiques etécologiques (informatique verte, netbook, ...). De plus, l’industrie approche de plus en plus des limitesphysiques de la micro-électronique où les transistors ne seront plus constitués que de quelques atomes etl’isolant entre eux d’un seul. Afin de mieux comprendre les rouages de cette programmation parallèle,nous allons présenter quelques notions élémentaires.

2.1.1 Préliminaires

Définition (Parallélisme). Le parallélisme en informatique donne la possibilité d’exécuter plusieurs ins-tructions conjointement.

11

Chapitre 2. SAT en parallèle

Définition (Exécution séquentielle, exécution parallèle). Une exécution séquentielle est une exécutionfaite sur une unité de calcul (cœur) tandis qu’une exécution parallèle est une exécution faite sur plusieursunités de calculs.

Définition (Temps d’exécution séquentiel, temps d’exécution parallèle). Le temps d’exécution d’un pro-gramme séquentiel représentant un problème P est le temps écoulé entre le lancement du programmeet l’obtention du résultat, nous le notons T P

sec. Le temps d’exécution d’un programme représentant unproblème P en parallèle sur n processus est l’instant où le dernier processus a terminé son travail, nousle notons T P

par(n).

Définition (Accélération absolue, accélération relative). L’accélération absolue représente le nombre defois que le programme a été accéléré grâce à son exécution en parallèle par rapport au temps d’exécutionséquentielle du meilleur algorithme connu résolvant un problème P :

Acc ab(n)=T Psec

T Ppar(n)

L’accélération relative représente le nombre de fois que le programme a été accéléré grâce à son exécutionen parallèle par rapport au temps d’exécution du même programme lancé sur un seul cœur :

Acc ab(n)=T Ppar(1)

T Ppar(n)

Définition (Efficacité). L’efficacité représente la qualité de la parallélisation en fonction du nombre deprocesseurs :

Eff(n)=Acc(n)

n

Définition (Extensibilité). L’extensibilité d’un algorithme parallèle est sa capacité à maintenir son effi-cacité quelque soit le nombre de processeurs utilisés.

Exemple. Les solveurs SAT ont souvent une extensibilité réduite due à la difficulté du probléme NP-Complet.

Définition (Accélération super linéaire, accélération linéaire, accélération sous linéaire). Quand une ac-célération dépasse le gain possible de la parallélisation, cela montre que le programme en question ob-tient donc aussi un gain algorithmique en plus de ce gain : cette accélération est dite super linéaire. Elleest obtenue lorsque Acc(n) > n pour n processeurs. Dans le cas contraire, si Acc(n) < n (respec-tivementAcc(n) = n) pour n processeurs, l’accélération est dite sous linéaire (respectivement linéaire).

Exemple. Pour un algorithme résolvant le problème SAT, des performances super linéaires sur une ins-tance sont possibles si le parallélisme a permis de diminuer fortement la taille de l’arbre de recherche enfonction du nombre de cœurs. Cela peut s’avérer fréquent pour des problèmes satisfiables, moins pourdes problèmes insatisfiables.Néanmoins, ce cas n’est pas abondant, il est difficile de trouver la bonnemanière pour partager l’arbre de recherche efficacement.

2.1.2 Modèles d’exécution

Il existe plusieurs manières d’exécuter plusieurs tâches simultanément, une classification nomméetaxinomie de Flynn [Fly72] a été élaborée afin de les distinguer. Elle contient donc l’architecture de von

12

2.1. Modèles parallèles

Neumann : modèle d’exécution des machines séquentielles.

Définition (SISD, SIMD, MISD, MIMD). La taxinomie de Flynn développe quatre modèles distincts :

− Single Instruction Single Data (SISD) : machine séquentielle d’un seul processeur pouvant traiter unseul flot d’instructions accompagné d’un seul flot de données ;

− Single Instruction Multiple Data (SIMD) : machine constituée de plusieurs processeurs pouvant traiterun seul flot d’instructions accompagné de plusieurs flots de données ;

− Multiple Instruction Single Data (MISD) : machine constituée de plusieurs processeurs pouvant traiterplusieurs flots d’instructions accompagnés d’un seul flot de données ;

− Multiple Instruction Multiple Data (MIMD) : machine constituée de plusieurs processeurs pouvanttraiter plusieurs flots d’instructions accompagnés de plusieurs flots de données.

Le modèle connu du monde séquentiel SISD n’exploite aucun parallélisme, tant au niveau des ins-tructions qu’à celui de la mémoire (architecture de von Neumann). SIMD est une machine qui utilise leparallélisme au niveau de la mémoire, comme le processeur vectoriel ou le processeur graphique (Gra-

phics processing unit (GPU)). MISD est un modèle spécifique à certain traitement qui est généralementutilisé pour sa tolérance envers les pannes, ce modèle s’exécute plus particulièrement sur des tableauxsystoliques de processeur. Pour finir, MIMD est le plus répandu, le plus souple à utiliser, et appliquerpar défaut dans le domaine SAT. Dans ce modèle, plusieurs processeurs traitent des données différentes,car chacun d’eux possède une mémoire distincte. Les ordinateurs multi-cœurs sont basés sur ce modèletandis que les supercalculateurs sont en général basés sur un MIMD hybride. Le modèle MIMD peut êtreexécuté sur différentes architectures selon la façon d’accéder à la mémoire, cette classification a été in-troduite par [Joh88].

Définition (CC-UMA, CC-NUMA, NoRMA). Le modèle MIMD a trois architectures cibles sur lesquelless’exécuter :

− Cache Coherent - Uniform Memory Access (CC-UMA) : la mémoire est globale et partagée à la mêmevitesse par tous les processeurs d’un ordinateur.

− Cache Coherent - Non Uniform Memory Access (CC-NUMA) : la mémoire est globale et partagée àdes vitesses différentes par tous les processeurs d’un ordinateur.

− No Remote Memory Access (NoRMA) : la mémoire est distribuée sur les processeurs, chaque proces-seur accède uniquement à sa mémoire locale.

Les architectures CC-UMA et CC-NUMA sont Cache Coherent, cela veut dire que la cohérence desmémoires caches est garantie par l’ordinateur. Dans l’architecture CC-UMA, chaque processeur accède àla mémoire à la même vitesse grâce à un bus d’interconnexion, ce qui limite la taille à quelques dizainesde cœurs. Typiquement, un ordinateur multi-cœurs est d’architecture CC-UMA. Par contre, l’architectureCC-NUMA ne possède pas de bus d’interconnexion : chaque cœur possède une mémoire locale qui lui estdirectement adressable à très grande vitesse et une autre, adressable par tous les cœurs, mais à vitesseréduite. Ce qui permet à cette architecture d’accueillir plus de cœurs que CC-UMA mais pour un coûtde cohérence des mémoires caches plus important. L’architecture NoRMA est très opposée aux deuxautres : elle ne possède pas de mémoire globale. Le partage de l’information s’effectue d’une manièredifférente : l’échange de messages entre processeurs à travers le réseau d’interconnexion. Néanmoins,cette architecture a l’atout de pouvoir compter plusieurs milliers de cœurs grâce à des difficultés deconception moindre. Le sujet de ce manuscrit, étant basé sur une application massivement parallèle de

13


SAT, se doit donc par défaut de choisir cette architecture. Remarquons que les supercalculateurs actuelssont en général constitués d’une hybridation des architectures présentées ci-dessus : quasiment tous baséssur une interconnexion NoRMA de nœuds CC-UMA ou CC-NUMA.

2.1.3 Modèles de programmation

Nous venons de voir que la communication entre les processeurs ne se fait toujours pas de la mêmefaçon suivant l’architecture utilisée, ainsi, cela a un impact sur les algorithmes et la manière de program-mer. Nous allons présenter ici, deux modèles conceptuels de communication pour écrire des algorithmesparallèles.

Définition (PRAM). Dans le modèle de programmation Parallel Random Access Machine (PRAM), la mé-moire est directement accessible par l’ensemble des processeurs. Or, les accès concurrents en écriture àla mémoire sont une complication pour le programmeur. Pour cela, il doit explicitement gérer des verrousd’accès pour s’assurer qu’un seul processeur accède à une variable lors de l’écriture. Les architecturescibles pour ce type de programmation sont les machines CC-UMA et CC-NUMA.

Définition (DRAM). Dans le modèle de programmation Distributed Random Access Machine (DRAM),chaque unité de calcul a seulement accès en temps constant à sa propre mémoire locale. La seule ma-nière de communiquer est de la faire explicitement par l’échange de messages. L’architecture cible est lamachine NoRMA.

Utile pour le modèle de programmation DRAM, la bibliothèque de fonctions Message Passing Inter-

face (MPI), conçue en 1993, est une norme utilisable avec les langages C, C++ et Fortran. Elle permetd’exploiter des ordinateurs distants ou multiprocesseurs par passage de messages. Le terme calcul paral-lèle (respectivement distribué) est associé au modèle de programmation PRAM (respectivement DRAM).A ne pas confondre avec la définition d’un algorithme distribué (ou réparti) qui est généralement un al-gorithme parallèle (mais pas toujours, exemple, une communication téléphonique) réparti sur plusieurssites. Nos approches dans ce manuscrit seront basées sur le modèle de programmation DRAM, qui pos-sède avec les algorithmes de colonies d’abeilles le point commun d’utiliser un système d’échange demessages. Nous allons maintenant étudier les approches pour résoudre SAT en parallèle.

2.2 Résoudre SAT en parallèle

Nous présenterons dans cette section les deux modèles permettant de faire travailler les processus enparallèle pour le problème SAT ainsi que quelques solveurs respectifs. D’une part, nous avons le modèlecollaboratif (coopératif) basé sur le paradigme « diviser pour régner » puis, d’un autre côté, le modèleconcurrentiel, qui exécute en parallèle plusieurs solveurs séquentiels en concurrence sur le même pro-blème. Nous acheminerons ainsi la notion de chemin de guidage, centrale dans le modèle collaboratif, quinous permettra de circonscrire une méthode originale nommée Cube And Conquer [HKWB12] étudiéedans la prochaine section.

2.2.1 Le modèle concurrentiel

Le modèle concurrentiel aussi nommé portfolio fait fonctionner les processeurs sur le même pro-blème sans le partager, mais en l’exécutant sur différentes stratégies de résolution avec des paramétragesdivers et variés. Ainsi, le premier trouvant la solution (SAT ou UNSAT) arrête tous les autres (figure 2.2).

14

2.2. Résoudre SAT en parallèle

Solveur 1

Solution

Solveur 2 Solveur 3 Solveur 4

FIGURE 2.2 – Parallélisme concurrentiel

Bien sûr, cela n’a de sens que pour les problèmes qui possèdent plusieurs algorithmes distincts à leur ac-tif fourmillant de paramètres sensibles ou ayant un comportement aléatoire. Il se trouve que le problèmeSAT en regorge et qui plus est, les solveurs modernes sont extrêmement sensibles au moindre change-ment de paramètre : cela s’explique par la structure interne des instances que connaît le problème SAT.Il est donc nécessaire que l’ensemble des solveurs fasse leurs recherches le plus différemment possibleafin de former un ensemble complémentaire. Les solveurs concurrentiels utilisent en général le modèlede programmation PRAM afin de pouvoir partager des informations utiles à tous les processeurs.

2.2.2 Les solveurs concurrentiels

Il existe de nombreux solveurs concurrentiels, nous en mentionnons une liste non exhaustive ayantpour but de voir une certaine évolution. Dans le domaine des solveurs incomplets, citons le parallélismedu solveur GNOVELTY+−T [PG09] qui est simplement l’exécution concurrentielle et indépendante deplusieurs solveurs GNOVELTY+ [PTGS08] utilisant une recherche locale stochastique afin de varier larecherche. Le solveur GNOVELTY+ utilise un mécanisme de poids sur les clauses non satisfaites, in-crémenté à chaque fois que la clause a été testée non satisfaite. Cela améliore le choix de la prochainevariable dont la valeur sera inversée.

Les solveurs complets modernes de type CDCL (ZCHAFF [Her03], MINISAT [SE02], PICOSAT [Bie08],...) sont une extension de la procédure DPLL. La procédure CDCL, d’abord introduite par [SS96], a ap-porté son lot d’améliorations au fil du temps : le backjumping, l’apprentissage de clauses, l’heuristiqueVSIDS, les restarts et une structure de données efficace nommée Watched literals. Un atout de la procé-dure CDCL dans le monde parallèle est le partage des clauses apprises parmi les solveurs exécutés. Lesolveur complet MANYSAT tente de tirer parti de cet avantage en jouant sur la sensibilisation des para-mètres des solveurs CDCL [HS09]. Il procède à un échange des clauses apprises parmi les processeurs.Néanmoins, un coût de communication ralentit la recherche, il faut donc décongestionner un canal decommunication trop encombré. Les auteurs mettent en place une limite basée sur la taille des clauseséchangées : elles doivent être de taille inférieure ou égale à 8. De plus, afin de réaliser une rechercheorthogonale et complémentaire, les auteurs proposent de différencier les solveurs sur leur stratégie deredémarrage, de choix de variables, de choix de polarité et d’apprentissage. D’un autre côté, le solveurPLINGELING propose d’échanger uniquement les clauses unaires avec des solveurs dont la stratégie dif-fère [Bie10].

15


Malgré cela, un simple outil de parallélisation statique PPFOLIO fait tourner les meilleurs solveursen concurrence sans échange de clause, et obtient de meilleurs résultats [Rou12]. A présent, nous allonsdétailler le solveur PENELOPE, possédant l’originalité de s’attaquer au surplus de clauses apprises enproposant de « geler » certaines d’entre elles [AHJ+12].

2.2.3 Le solveur PENELOPE

PENELOPE [AHJ+12] est un solveur concurrentiel de type portefolio reprenant pour socle le sol-veur MANYSAT. Intégrant les approches efficaces du cadre séquentiel (propagation unitaire, structure dedonnées paresseuses, heuristique basée sur l’activité des variables, apprentissage de clauses, etc.), sonatout est d’intégrer une technique récente permettant d’aménager la base de clauses apprises pour lesdifférencier suivant leur utilité à un instant donné du solveur.

Voyons tout d’abord la notion du progress saving qui consiste à préserver la dernière polarité dechaque variable dans une interprétation complète notée P . Ainsi quand une décision sera prise, le solveurchoisit pour valeur de vérité d’une variable de décision cette polarité sauvegardée. Le travail accomplipar le solveur pour résoudre les sous-problèmes traversés avant d’atteindre un conflit devient donc plusutile [PD07]. Néanmoins, cette technique a le désavantage de ne pas assez diversifier la recherche.

Pour gérer la base de clauses apprises, les auteurs de [ALMS11] ont défini une mesure nomméeprogress saving based quality measure (PSM) définie comme suit : pour une clause C et une interprétationcomplète P représentant la dernière polarité de chaque variable (le progress saving) :

PSM(C) = | P ∩ C |

Quand PSM(C)est petit, la clause C a plus de chance de participer à la propagation unitaire, elle est doncpour nous importante et pertinente. A l’inverse, si PSM(C)est grand, cela signifie que la clause a plus dechance d’être satisfaite par un littéral, elle est donc moins utile à cet instant de la recherche. Cet effet estdû à l’interprétation P qui nous donne une image de l’état courant de la recherche.

L’heuristique PSM est utilisée pour classer les clauses apprises des solveurs. On peut distinguer 3types de clauses apprises :

− Les clauses actives A : clauses utilisées dans la recherche ;

− Les clauses gelées G : clauses inutilisées dans la recherche mais encore en mémoire (enlevées dela liste des watched-literals) ;

− Et les clauses supprimées S de la mémoire.

Périodiquement, la mesure PSM est calculée sur toutes les clauses apprises. Suivant un seuil L, lesclauses ayant un petit PSM < L sont activées. A l’opposé, les clauses avec un grand PSM > L sont gelées.Grâce au calcul périodique de PSM, les clauses changent donc de camp, pour devenir gelées ou dégelées(actives), suivant la recherche en cours. De plus, les clauses restant gelées trop longtemps et les clausesactives mais sans participation à la recherche depuis un trop long laps de temps K sont supprimées, cequi nous donne notre troisième type de clauses apprises (figure 2.3).

2.2.4 Le modèle collaboratif

Le modèle collaboratif consiste à réduire récursivement l’arbre de recherche en plusieurs sous-problèmes du même type (figure 2.4). Pour cela, plusieurs approches ont été proposées souvent bâties

16


Non utilisée ( ) Non ac

tivée

( )

FIGURE 2.3 – Diagramme des clauses apprises dans PENELOPE

FIGURE 2.4 – Parallélisme « diviser pour régner »

sur une programmation ne demandant que des échanges minimes : le modèle DRAM. Nous exposeronsla plus utilisée, qui découpe l’arbre de recherche sous forme de trajet, intitulée chemin de guidage.Néanmoins, bien que cette division semble parfaite pour un solveur de type DPLL, elle pose souci auniveau des backtracks non chronologiques d’un solveur CDCL : il se peut qu’un processeur travaille pourrien. Un autre désavantage est la charge des processeurs qui est déséquilibrée, en effet, la division del’arbre de recherche nous donne deux sous-problèmes dont les difficultés diffèrent. Il faut donc amenerune politique d’équilibrage de charge qui peut s’avérer coûteuse. De plus, contrairement à la méthodeconcurrentielle, cette technique doit attendre que tous les solveurs ont terminé leurs recherches pourprouver l’intisfaisabilité d’une instance.

2.2.5 Le chemin de guidage

Dans cette section, nous présenterons l’approche la plus populaire du modèle collaboratif : cette no-tion appelée chemin de guidage (Guiding path) a été proposée par [ZB94]. Cette approche consiste àconserver des chemins de recherche permettant d’indiquer quels sont les sous-arbres à développer pourun processeur. Un tel chemin est représenté par un ensemble de couples (Fi,Ci), ou Fi est un littéral àpropager et Ci est une variable booléenne indiquant quelles branches sont en cours de calcul parmi lesdeux sous-arbres disponibles à partir de la variable provenant du littéral Fi. Cette variable booléenne estdéfinie comme suit :

− Ci = ⊥ ⇔ les deux sous-arbres sont en cours de traitement ou traités.

− Ci = ⊤ ⇔ un seul des deux sous-arbres est en cours de traitement ou traité.

17


Exemple. Le chemin de guidage de la figure 2.5 est ((x1,⊤),(x2,⊤),(¬x3,⊥)). A partir de celui-ci,il est possible d’obtenir deux chemins de guidage différents qui permettront d’orienter deux proces-seurs : ((¬x1,⊥)) et ((x1,⊥),(x2,⊤),(¬x3,⊥)). Par la suite, si un troisième processeur est inutilisé,nous pouvons appliquer ce même raisonnement sur la variable x2 pour avoir trois chemins de guidage :((¬x1,⊥)), ((x1,⊥),(¬x2,⊥)) et ((x1,⊥),(x2,⊥),(¬x3,⊥))

FIGURE 2.5 – Chemin de guidage

Cette notion présente le défaut de donner au processeur des chemins dont le calcul est déséquilibré,en effet, il se peut qu’un chemin soit très long à calculer tandis qu’un autre se finisse instantanément. Afinde pallier à ce problème, un modèle d’équilibrage de charge doit être installé. De plus, il est possible dediviser le travail en deux sous-chemins, l’un contenant le littéral et l’autre, son littéral complémentaire.

2.2.6 Le chemin de guidage : le rééquilibrage des charges

Le rééquilibrage des charges est basé sur un modèle maître/esclave comme peut nous montrer lafigure 2.6. Un processeur maître est chargé de distribuer les tâches aux esclaves tandis qu’un processeuresclave est chargé de calculer une tâche. Le modèle mis en place pour équilibrer la charge par unedistribution des chemins de guidage est généralement centralisé au sein du processeur maître. Le maîtremaintient à jour une liste de chemins de guidage. Un chemin permet de symboliser le futur travail sur unsous-arbre puisque le chemin permet de retrouver la racine d’un sous-arbre. Un exemple du rééquilibragedes charges exposé est donné par les figures 2.7, 2.8, 2.9, 2.10, 2.11 et 2.12, partiellement tirés de [VS09].

18


✕

✕

FIGURE 2.6 – rééquilibrage des charges : état initial, F et G travaillent.

✕

✕

✕

FIGURE 2.7 – rééquilibrage des charges : F a terminé son sous-arbre, G travaille.

✕

FIGURE 2.8 – rééquilibrage des charges : F informe le maître, G travaille.

19


✕✕

FIGURE 2.9 – rééquilibrage des charges : F récupère un chemin de guidage depuis le maître.

✕✕

FIGURE 2.10 – rééquilibrage des charges : le maître n’a plus de chemin à fournir, il stoppe G

✕✕

FIGURE 2.11 – rééquilibrage des charges : G envoie son chemin de guidage

20

2.3. Cube And Conquer

✕✕

FIGURE 2.12 – rééquilibrage des charges : les chemins de guidage sont rééquilibrés

Par le fait qu’un chemin de guidage peut se représenter par quelques entiers seulement, cette mé-thode a largement été étudiée en pratique dans un modèle DRAM. À présent, nous présentons brièvementquelques solveurs basés sur ce principe.

2.2.7 Les solveurs de type chemin de guidage

Le premier solveur parallèle utilisant cette technique est PSATO [ZBP+96] basé sur le solveur sé-quentiel SATO. Par la suite, certaines bonifications sont apparues, //SATZ [JLU01] avec l’intégrationde l’heuristique basée sur la propagation unitaire (PU) , l’échange de clauses a été intégré par PASAT[SBK01]. Citons aussi PMINISAT [CSH08] qui est la parallélisation du solveur MINISAT 2.0 [SE08] avecla particularité d’exploiter les chemins de guidage des processus pour améliorer la qualité des clauseséchangées. A présent, nous allons exposer un solveur collaboratif qui a pour intuition de diviser le pro-blème sans chemin de guidage.

2.3 Cube And Conquer

T F

CREATION D'UN CUBE

CONFLIT

T F

✕✕

T F T F

✕

T FT F

✕

FIGURE 2.13 – Cube And Conquer

21


La méthode Cube And Conquer (CC) a été introduite par [HKWB12] et vise à réduire le temps derésolution des instances difficiles. Cette approche divise le problème en deux phases, la première appeléeCube (figure 2.13) consiste à transformer le problème original en million de cubes via un solveur look-

ahead tandis que la deuxième phase appelée Conquer consiste à résoudre chaque cube dans des solveursCDCL distincts (spirales de figure 2.13). L’intuition est qu’un solveur CDCL est très efficace sur de pluspetites instances grâce à leur heuristique basée sur l’activité des variables alors qu’un solveur look-ahead

prend de meilleures décisions au début de l’arbre de recherche, étant basées sur une heuristique globale.Cette méthode a donc pour but de passer d’une résolution look-ahead à une résolution CDCL de typelook-back quand un des sous problèmes semble devenir facile. Pour finir, elle a l’avantage d’être paral-lélisable par sa nature.

Exemple. Soit F une formule sous forme CNF représentant notre instance initiale. La figure 2.13 repré-sente l’arbre de recherche par un solveur look-ahead. En parcourant cet arbre de recherche, suivant uneheuristique, l’algorithme a créé quatre cubes, qu’il ajoutera à F pour envoyer chaque formule modifiéeFn (représentant nos sous problèmes plus faciles) à des solveurs CDCL distincts :

− F1 = F ∧ (x2 ∧ x3 ∧ x1)

− F2 = F ∧ (x2 ∧ x3 ∧ ¬x1)

− F3 = F ∧ (¬x2 ∧ x1)

− F4 = F ∧ (¬x2 ∧ ¬x1 ∧ ¬x3)

2.3.1 Algorithme

Les auteurs ont donc modifié le solveur look-ahead pour en faire un outil de partitionnement duproblème initial. Ils se base sur un solveur DPLL, en lui ajoutant une heuristique look-ahead, nous avonsdonc un parcours en profondeur d’abord avec backtrack via un algorithme récursif.

Algorithme 1 : CC

Données : F la formule initiale, A l’ensemble de cubes, C l’ensemble de clauses apprises,l’ensemble des littéraux de décisions Ld et l’ensemble des littéraux impliqués via lapropagation unitaire Li.

Résultat : A l’ensemble des cubes envoyé à des solveurs CDCL distincts1 Début2 (F ,Li)←− simp(F ,Ld,Li);3 si falsifie(Ld,Li) alors /* Un conflit */

4 retourner (A,C ∪ {¬Ld}); /* Apprend une clause */

5 si coupureHeuristique() alors6 retourner (A ∪ {Ld},C); /* Ajoute le cube */

7 L←− decisionHeuristique(F ,Ld,Li);8 (A,C)←− CC(F ,A,C,Ld ∪ {L},Li);9 retourner CC(F ,A,C,Ld ∪ {¬L},Li);

10 Fin

Pour chaque nœud de l’arbre de recherche, l’algorithme 1 représentant CC va d’abord effectuer lapropagation unitaire et d’autres simplifications, cela peut impliquer d’autres littéraux (ligne 2). Ensuite,il regarde s’il y a un conflit (ligne 3) : si c’est bien le cas, il apprend la clause responsable du conflit (le

22

2.3. Cube And Conquer

complément du cube représentant les décisions de la racine aux feuilles) dans l’ensemble C, puis l’al-gorithme va donc terminer la récurrence (ligne 4). Par la suite, via une heuristique nommée de coupure,l’algorithme choisit si il peut envoyer le cube à un solveur CDCL (ligne 5). Dans ce cas, il retient le cubedans l’ensembleA et ici aussi, la récurrence se termine (ligne 6). Pour finir, cet algorithme fait les appelsrécursifs courants d’un solveur DPLL (ligne 8 et 9) en décidant un littéral via une heuristique de choixde variables look-ahead (ligne 7). A la fin de la procédure, l’ensemble des clauses C et l’ensemble descubes A sont optimisés. Les solveurs CDCL reçoivent F ∧ (a ∈ A) ∧ C, soit la formule accompagnéed’un cube a avec optionnellement quelques clauses apprises. Comme nous le montre l’exemple suivant,les clauses de C forceront dans certains cas quelques variables, que nous pouvons donc enlever de diverscubes.

Exemple. Toujours sur notre figure 2.13, les deux premiers conflits représentés par une croix sont lescomplémentaires des décisions de la racine à leur feuille, on a donc les clauses apprises ¬x2 ∨ x3 ∨¬x4et ¬x2 ∨ x3 ∨ x4. A la fin de l’algorithme, une optimisation effectue une résolution sur ces deux clausespour en faire une seule : ¬x2 ∨ x3. Ainsi quand x2 sera affectée, la clause propagera x3. On peut doncenlever la variable x3 des cubes qui contiennent la variable x2 sans oublier d’ajouter cette clause appriseaux solveurs CDCL. Cela donne :

− F1 = F ∧ (x2 ∧ x1) ∧ C

− F2 = F ∧ (x2 ∧ ¬x1) ∧ C

− F3 = F ∧ (¬x2 ∧ x1) ∧ C

− F4 = F ∧ (¬x2 ∧ ¬x1 ∧ ¬x3) ∧ C

Remarque. Bien que ces clauses apprises soient utiles à cette optimisation, les auteurs signalent quel’envoi de ces clauses apprises à un solveur CDCL est optionnel. En effet, le sous-problème généré étantdifférent du problème initial, il y a peu de chance que les clauses apprises près de la même branche(celle formant le cube) servent réellement au sous-problème. Néanmoins, une clause apprise d’une autrebranche (Une branche différente du cube) pourrait servir au sous-problème, surtout si sa taille est petite.

Deux heuristiques sont utilisées dans CC : l’heuristique de coupure et l’heuristique de décision. Lapremière est utilisée pour savoir s’il faut couper l’arbre de recherche (arrêter de développer une branche)pour envoyer un cube à un solveur CDCL ou alors, ne rien couper et continuer la recherche. Tandis quela deuxième, sert à choisir la prochaine variable à développer au prochain nœud.

2.3.2 L’heuristique de coupure

Les auteurs ont implémenté trois heuristiques différentes pour sélectionner celle qui coupe au mieuxl’arbre, c’est la dernière qui s’est révélée la plus efficace.

La méthodeA propose de couper les branches après un certain nombre de décisionsK fixé à l’avance,l’avantage est de savoir le nombre maximal de cubes : 2K qui pourront être crées. Un inconvénient ma-jeur : les cubes coupés au même niveau de l’arbre sont disproportionnés au niveau de leur difficulté :certains seront très faciles à résoudre tandis que d’autres très durs.

La méthode B propose de couper les branches dès qu’on a dépassé un pourcentage du nombre des va-riables assignées. Elle pose principalement problème dans le fait que pour certaines instances, le nombrede cubes devient très grand alors que pour d’autres, il devient trop petit.

23


La méthode C est l’heuristique intégrée dans CC. Elle utilise un produit avec le nombre de décisionset un autre avec le nombre de variables puis l’affine suivant une variable dynamique α. La branche estcoupée à la condition de respecter cette inéquation :

Nbdec ∗Nbdec ∪ imp > α ∗Nbvar

avec :

− Nbdec est le nombre de variables de décisions ;

− Nbdec ∪ imp est le nombre de variables de décisions plus le nombre de variables impliquées ;

− Nbvar est le nombre de variables de la formule initiale ;

− α est la variable dynamique qui est initialisée à 1000.

A chaque appel, la variable α est augmentée de 5 pour empêcher qu’elle ne devienne pas trop petite. Puislors d’un conflit, elle est diminuée de 15 pour essayer de couper les branches voisines avant l’apparitiond’autres conflits : de ce fait, plus il y a de conflits, plus l’algorithme crée des cubes. Cela permet aussi dene pas aller trop en profondeur dans l’arbre de recherche. A partir d’un certain moment choisi suivant lenombre de décisions, on abaisse toujours α pour couper toute les branches afin de créer tous les cubesen quelques secondes.

2.3.3 L’heuristique de choix de variables

Les auteurs ont utilisé une heuristique basée sur la fonction eval(X)comptant le nombre de litté-raux assignés grâce à la propagation du littéral X . Le solveur CC choisit ensuite la variable maximisanteval(X)∗ eval(¬X), les égalités sont brisées par eval(X)+ eval(¬X). Ils expliquent leurchoix en citant deux avantages : le premier est qu’elle est simple comparée à une heuristique lourdeen calcul, comme celle basée sur les clauses réduites mais non satisfaites. De ce fait, elle ne requièrepas la structure de données complexe souvent implémentées dans les solveurs look-ahead. Le deuxièmeavantage pour les auteurs, est que cette heuristique est meilleure sur des instances qui contiennent beau-coup de clauses binaires comme nous pouvons en trouver dans les instances industrielles. En effet, nouspouvons remarquer que plus une instance contient de clauses binaires, plus l’ensemble d’arrivée de lafonction eval(X)sera diversifié, ce qui augmentera son efficacité. En contrepartie, quand il n’y a pasou peu de clauses binaires, cela réduira considérablement son efficacité.

2.3.4 La résolution des cubes

Les auteurs se reposent sur un outil de parallélisation appelé TARMO, celui ci se base sur les travauxde la notion Bounded Model Checking (BMC). La technique multijob utilisée pour CC consiste à attribuerun job (cube) dès qu’un nœud de calcul est au repos. Quand deux nœuds sont au repos en même temps,l’ordre d’assignement des cubes est indéfini, mais il est garanti que deux nœuds ne fonctionneront jamaissur le même cube. Les auteurs ont aussi expérimenté une autre stratégie appelée multijob+ qui se basesur multijob excepté qu’il peut assigner un cube qui est déjà en train d’être résolu par d’autres nœudsde calculs à un nœud qui serait de toute façon resté au repos. Cela découle du fait que certains cubessont très faciles et se résolvent donc rapidement tandis que d’autres sont trop longs à résoudre. Grâce àcette amélioration, une fois que les cubes les plus simples ont été résolus, tout les autres sont sur tousles nœuds de calculs plusieurs fois si le nombre de nœuds de calculs le permet. Pour finir, remarquonsque le solveur CC ne rivalise pas avec les solveurs actuels, mais il obtient quand même de meilleureperformance avec une réelle marge sur quelques instances difficiles.

24

2.4. Conclusion

2.4 Conclusion

Dans le chapitre 4 de la partie de contribution, nous avons conclu sur le fait que les algorithmesde colonies d’abeilles adaptés au problème SAT doivent d’abord avoir une base sur laquelle ces méta-heuristiques peuvent s’appuyer. Comme pour CC, nous proposons donc de diviser notre problème enmillion de cubes, afin d’obtenir le nectar en question. Un cube sera donc considéré comme un sous-problème, et plusieurs cubes seront considérés comme une nourriture pour une méta-heuristique de colo-nies d’abeilles. Nous pouvons considérer cette création de cubes comme l’illustration d’une abeille scoutdu chapitre 4 ayant la même fonctionnalité. Néanmoins, nous devons donc trouver les meilleurs cubes,la qualité d’un tel cube (interprétation partielle) est difficile à connaître réellement dans une complexitécorrecte, mais nous pouvons en faire une estimation. Nous entendons par meilleur les cubes qui mènentà une solution pour les instances SAT. Quand aux instances UNSAT, nous ne pouvons que considérer leurfacilité ou difficulté à prouver leur insatifaisabilité. Afin d’étudier une manière de trouver les meilleurscubes, nous allons examiner les problèmes de bandits ainsi que l’algorithme UCT. En effet, ce problèmetraite un dilemme d’exploration / exploitation, dilemme que nous pouvons retrouver dans la création decubes.

25

Chapitre 3

Les problèmes de bandits

Sommaire

3.1 Le problème de bandits classique . . . . . . . . . . . . . . . . . . . . . . . . . 263.1.1 Multi-armed bandit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.1.2 La stratégie d’allocation et regret . . . . . . . . . . . . . . . . . . . . . . 27

3.2 La stratégie UCB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283.2.1 Définition et exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

3.2.2 Exemple d’application . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

3.3 L’algorithme UCT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303.3.1 Squelette de l’algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . 30

3.3.2 Explication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

3.3.3 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

CE CHAPITRE a pour but d’initier le lecteur au dilemme exploration / exploitation rencontré lors denos travaux dans le chapitre 5, ainsi qu’une méthode prenant en compte ce dilemme. Pour cela,

nous allons tout d’abord présenter le problème de bandits (manchots) classique à K bras. Puis, aprèsavoir défini la notion de stratégie et de regret, présenter la stratégie UCB qui respecte intuitivement notredilemme. Nous finirons par expliquer l’algorithme UCT qui applique cette stratégie. Le lecteur intéressépourra se référer à l’introduction de [ACBF02], et [ACBFS03].

3.1 Le problème de bandits classique

Dans de nombreux problèmes, il peut se cacher un dilemme exploration / exploitation (EvsE) : unagent peut être confronté au compromis fondamental entre accumuler de l’expérience afin d’obtenirdes informations sur les récompenses qu’il peut avoir grâce à des choix (exploration), ou au contraire,exploiter ces informations pour faire le choix le plus prometteur (exploitation). Les problèmes de banditsillustrent ce dilemme.

3.1.1 Multi-armed bandit

Un bandit manchot (One-armed bandit) est l’expression familière d’une machine à sous, commenous pouvons en trouver dans tous les casinos. Le problème de bandits (manchots) classique à K bras(Multi-Armed Bandit (MAB)) originellement proposé par [Rob52] représente K machines à sous ayant

26

3.1. Le problème de bandits classique

chacune un bras (options, actions, choix) comme nous montre la figure 3.1 :

Définition (Multi-armed bandit problem). Un agent choisit à chaque instant une action parmi les K dé-cisions possibles et reçoit une récompense aléatoire tirée selon une distribution déterminée par l’actionchoisie. Le but du joueur est de maximiser son gain : la somme des récompenses qu’il reçoit au coursd’une séquence des tirages des bras. Dans ce cas, chaque bras est supposé donner des gains qui sont tirésde façon indépendante à partir d’une répartition fixe et inconnue. Comme les distributions de récom-penses diffèrent de bras à bras, l’objectif est de trouver le bras avec le meilleur gain le plus tôt possible,et de ne se focaliser que sur ce dernier.

FIGURE 3.1 – Des bandits manchots

Formellement, ce problème est défini par des variables aléatoires Xi,n avec 1 ≤ i ≤ K et n ≥ 1,où i est le numéro d’un bras et n dénote l’instant considéré. Le tirage successif du bras i rapporte desrenforcements Xi,1, Xi,2, ... selon une loi de moyenne (espérance) µi.

3.1.2 La stratégie d’allocation et regret

Définition (Stratégie d’allocation). Une stratégie d’allocation est un algorithme déterminant le bras àjouer à l’instant n+ 1 en se basant sur la séquence des bras déjà tirés.

Pour évaluer la performance d’une stratégie d’allocation donnée, nous devons savoir à quelle vitessecette stratégie permet d’atteindre un taux de récompense moyen optimal. Pour cela, nous définissons leregret depuis l’instant n comme étant la perte par rapport à la stratégie optimale. La valeur moyennedu meilleur bras est donc le bras qui a l’espérance maximale à chaque instant : µ∗ = maxµi avec1 ≤ i ≤ K. Nous devons donc connaître ses probabilités de gain : quand l’agent connaît les lois, ilchoisit alors le meilleur bras à chaque instant et obtiendrait une récompense moyenne µ∗.

Définition (Le regret cumulé). Le regret cumulé à l’instant n est alors défini par :

Rn = nµ∗ −n∑

t=1rt

qui représente la différence en récompenses cumulées entre ce qu’il a obtenu et ce qu’il aurait pu obteniren moyenne s’il avait joué d’une façon optimale dès le début. rt est donc le gain obtenu par le bras àl’instant t.

Exemple. Soit 4 bandits manchots dont les probabilités de gain sont connues : nous venons de tirer 3fois le deuxième bras qui nous donne les gains 0.3, 0.4 et 0.6. Nous savons que le premier bras a une

27

Chapitre 3. Les problèmes de bandits

récompense moyenne (espérance) µ∗ = 0.8 qui est maximale. Ce qui nous donne donc un regret cumuléà cet instant de R3 = 3 ∗ 0.8− (0.3 + 0.4 + 0.6) = 1.1.

Remarque. Avec de la chance, nous pouvons avoir un regret cumulé négatif si nous jouons le meilleurbras.

Définition (Le regret cumulé espéré). Le regret cumulé espéré à l’instant n est alors définie par :

Ren = nµ∗ − µj

K∑

j=1E[Tj(n)]

Tj(n) est le nombre de fois où le bras j a été tiré depuis l’instant n. µj est l’espérance des récompensesdes bras tirés par la stratégie, donc liés à E[Tj(n)]. Le regret cumulé espéré est ainsi l’espérance de pertedue au fait que la stratégie d’allocation ne joue pas systématiquement le meilleur bras.

Le regret cumulé espéré est utilisé pour trouver une bonne stratégie d’allocation : en effet, nous nousintéressons à définir des stratégies qui obtiennent un petit regret cumulé espéré. Ainsi, un bon algorithmede bandit devra tirer peu souvent les bras sous-optimaux.

3.2 La stratégie UCB

La stratégie Upper Confidence Bounds (UCB), a été introduite à partir des années 2000, les auteursl’ont formalisée dans [ACBF02].

3.2.1 Définition et exemple

La stratégie UCB résout le compromis exploration/exploitation en choisissant à chaque tour, parmitous les bras possibles, celle qui maximise la somme d’un terme d’exploitation, et d’un terme explora-tion. Cette stratégie associe une valeur appelée indice de confiance supérieure (UCB) à chaque bras.

Définition (Stratégie UCB). Pour initialiser l’algorithme, nous jouons une fois chaque bras, notons toutd’abord :

− Ti(n) : le nombre de tirages du bras i jusqu’à l’instant n ;

− Si(n) : la somme des récompenses obtenues du bras i jusqu’à l’instant n ;

− Mi(n) =Si(n)

Ti(n)est donc la moyenne à l’instant n des récompenses obtenues du bras i.

Lorsque Ti(n) > 0, l’indice UCB associé au bras i est :

UCBi(n) = Mi(n) +

√

2 lnn

Ti(n)(3.1)

La stratégie UCB pour un instant n choisit le bras tel que :

UCB(n) = max1≤i≤K

UCBi(n)

Remarque.

− Le terme d’exploitation Mi(n) : moyenne des gains obtenue en choisissant cette action ;

28

3.2. La stratégie UCB

− Le terme d’exploration

√2 lnn

Ti(n): moins l’action a été choisie dans le passé, plus ce terme est

élevé.

Nous obtenons ainsi un bon compromis : lorsque nous jouons un grand nombre de fois, la probabilité

d’explorer tend vers 0 avec une vitesse de convergence vers la stratégie optimale enln(n)

nou n est le

nombre de tirages : nous parlons alors de stratégie optimale dans l’incertain.

Exemple. Soit 3 bandits manchots, nous venons de tirer deux fois le premier bras qui nous donne lesgains 0.3 et 0.4, puis deux fois, le deuxième bras qui nous donne les gains 0.3 et 0.5. Pour finir, letroisième bras n’a été joué qu’une seule fois avec un gain de 0.5, nous sommes donc à l’instant n = 4.Nous cherchons via la stratégie UCB le prochain bras à jouer, calculons :

− M1(4) = (0.3 + 0.4)/2 = 0.35

− M2(4) = (0.3 + 0.5)/2 = 0.4

− M1(4) = 0.4/1 = 0.4

− UCB1(4) ≈ 0.35 + 1, 177 ≈ 1, 527

− UCB2(4) ≈ 0.4 + 1, 177 ≈ 1, 577

− UCB3(4) ≈ 0.4 + 1, 665 ≈ 2, 065

Nous choisissons donc le troisième bras. Remarquons que le terme d’exploration du troisième bras estplus élevé que les autres (1.665 vs 1,177), UCB cherche donc à explorer, ce qui est normal car noussommes seulement à l’instant n = 4.

3.2.2 Exemple d’application

D’autres stratégies de type UCB sont proposées dans [ACBF02] puis dans [AO10]. Dans [JLHS12],les auteurs proposent d’utiliser cette approche pour résoudre un compromis exploration/exploitation dansun solveur parallèle. Dans MANYSAT, tous les cœurs partagent et échangent les clauses apprises dont lataille ne dépasse pas un certain seuil. Cependant, étant donné le coût de communication, cette approcheest inefficace lorsque le nombre de cœurs de calcul augmente. Ainsi, afin de décongestionner le canal decommunication, il est nécessaire de définir quels seront les cœurs autorisés à partager leurs informations.Pour cela, les auteurs ont défini un algorithme : Bandit Ensemble for parallel SAT Solving (BESS) quis’inspire du problème du bandit manchot et de la stratégie UCB.

L’approche BESS utilise un MAB particulier pour les cœurs récepteurs. Un émetteur est dit vivant dansune certaine période s’il est autorisé à envoyer des clauses, autrement, un émetteur est dit dormant. Aucommencement de chaque période, le MAB particulier décide si un émetteur vivant reste en vie, sinon,il devient un émetteur dormant, et le plus vieux émetteur dormant est réveillé. Dans chaque période detemps, le MAB a pour tâche :

− Calcule le gain instantané du récepteur : le gain instantané d’un émetteur en vie par rapport àun récepteur est défini en fonction d’une heuristique inspirée de Variable State Independant De-

caying Sum (VSIDS). Grâce à cette heuristique, les auteurs mettent à jour le gain cumulé de chaqueémetteur en vie ;

− Met à jour un seuil de vitalité inspiré d’UCB ;

− L’émetteur vivant devient en sommeil si son gain cumulé est inférieur au seuil de vitalité et, dansce cas, l’émetteur en sommeil qui a été endormi le plus longtemps est réveillé.

29


3.3 L’algorithme UCT

L’algorithme UCB ne peut cependant pas être utilisé tel quel dans les jeux où les gains peuvent sub-venir bien après l’action, comme certains jeux de stratégie (échec, go) : c’est dans l’optique de résoudrecette limite que l’algorithme Upper Confidence bounds in Trees (UCT) a été mis au point par [KS06].

3.3.1 Squelette de l’algorithme

Répéter N fois

DESCENTE

SÉLECTION

REMONTÉE

SIMULATION

FIGURE 3.2 – Étape de l’algorithme UCT.

Pour utiliser l’algorithme UCT, Il faut tout d’abord un arbre de recherche, en l’occurrence dans cechapitre, un arbre de recherche représentant un jeu à deux joueurs (échec, go, ...), sachant que cet al-gorithme peut être adapté dans d’autres contextes. De ce fait, l’arbre des possibles est donc l’arbre detoutes les parties possibles depuis une position donnée. Chaque nœud représente donc un coup à jouer,dans une position donnée sauf le nœud racine. Comme nous montre la figure 3.2, l’algorithme UCT sedivise en plusieurs étapes répétées N fois :

30

3.3. L’algorithme UCT

− La descente dans l’arbre de recherche ;

− La sélection d’une feuille ;

− La simulation d’un nœud de l’arbre (un état du jeu) ;

− La remontée dans l’arbre de recherche.

Algorithme 2 : UCT

Données : A un arbre de recherche ne contenant que la racine d’une position donnée du jeu et Nle nombre de descentes dans l’arbre

Résultat : L’arbre A contenant le prochain coup à jouer : c’est le nœud fils de la racine qui a lemeilleur UCB

1 Début2 tant que N > 0 faire3 P ←− descenteSelectionUCT(racine(A));4 R←− simulation(P);5 remontéeUCT(A,P,R);6 N ←− N+1;

7 retourner A;8 Fin

L’algorithme 2 associé à notre figure 3.2 a l’originalité d’explorer l’arbre de recherche d’une manièreasymétrique en réalisant un bon compromis pour notre dilemme fondamental exploration/exploitation.L’algorithme UCT simule itérativement des parties dans un jeu : les coups de la racine jusqu’à des feuillesdans notre arbre de recherche. Une version récursive peut être vue dans [KS06] et [CM10]. Nous allonsprésenter une version itérative, notons que la version récursive a l’atout de faire les étapes descente etremontée d’une manière récursive dans l’arbre.

3.3.2 Explication

Algorithme 3 : descenteSelectionUCT(R)Données :R la racine de l’arbre ARésultat : Le nœud F sélectionné

1 Début2 tant que filsNonExploré(F)= ∅ faire3 F ←− filMaxUCT();4 JouerCoup(R,F);5 R←− F ;

6 F ←− FilsNonExploréHasard(R);7 devientExplorer(F);8 JouerCoup(R,F);9 retourner F ;

10 Fin

L’algorithme UCT s’adapte suivant le problème en question. Grâce à l’indice UCB, il exploite en conti-nuant d’explorer les branches qui semblent les meilleures compte tenu des feuilles qu’il a déjà explorées

31


(exploitation), et il explore des branches encore mal connues (exploration). Dans l’algorithme 3 de lafonction descenteSelectionUCT()(ligne 3 dans l’algorithme 2), nous faisons la distinction pourles fils d’un nœud entre ceux qui sont explorés et ceux qui ne le sont pas (filsNonExplorer()(ligne2)), l’intersection de ces deux ensembles est donc vide, la fonction devientExplorer()(ligne 7)rend un nœud exploré. filMaxUCT()(ligne 3) prend le fils ayant le plus grand indice UCT. La fonctionJouerCoup()(ligne 4 et 8) simule le coup d’un joueur d’un nœud à un autre dans la partie. La fonctionFilsNonExplorerHasard()(ligne 6) fait l’étape de la sélection qui renvoie, dans notre cas, un filsau hasard. Remarquons que nous pouvons faire la simulation sur chacun des fils puis sélectionner celuiayant le meilleur gain, néanmoins, dans certains jeux (go, ...) et problèmes (SAT, CSP, ...), il peut y avoirbeaucoup trop de fils à chaque nœud pour pouvoir appliquer cette méthode.

La simulation dépend du problème, il peut y avoir des jeux, où le nœud sélectionné est une feuillede l’arbre, dans ce cas, il n’y pas de simulation, et il suffit de regarder l’état de la partie pour savoir si lapartie est gagnante ou pas. Mais dans la plupart des jeux, les arbres sont tellement immenses qu’il faututiliser une simulation car nous atteignons très rarement les feuilles de l’arbre. Cela consiste à trouverune fonction d’évaluation qui permet d’évaluer l’état de la partie. Ainsi, il est très appréciable de trouverune fonction d’évaluation permettant d’évaluer correctement l’état de la partie. En général, pour de nom-breuses applications, la fonction utilisé consiste à appliquer une méthode de type sampling (par exempleMonte-Carlo). Cependant, dans le cadre de SAT, une telle approche ne peut pas être utilisée et c’est doncdes heuristiques usuelles qui sont utilisées.

Définition (Algorithme de Monte Carlo). un algorithme de Monte-Carlo est un algorithme probabilisted’une complexité déterministe, parfois dit aussi « randomisé » dont le déroulement fait appel à des don-nées tirées au hasard. Le résultat peut être incorrect avec une certaine probabilité (généralement faible).

Exemple. Nous imaginons une course entre 8 athlètes dont les chronos sont modélisés par autant devariables aléatoires. Nous avons besoin de savoir quel temps en moyenne met le plus lent des coureurs :

− Nous simulons les chronos des 8 coureurs et nous déterminons leur maximum : nous le faisons Nfois en tout ;

− Nous faisons la somme des Nchronos maximum ;

− Nous divisons cette somme par N .

Remarque. La méthode de Monte-Carlo offre un intervalle de confiance calculé grâce au nombre d’ex-périences.

La remontée consiste à re-parcourir les nœuds dans le sens inverse, pour remonter le gain de lasimulation effectuée. Il existe plusieurs manières de remonter les gains suivant le problème : pour cechapitre, nous les remontons suivant le joueur en question dans le nœud comme nous montre l’algorithme4.

32

3.3. L’algorithme UCT

Algorithme 4 : remontéeUCT(P,R)Données : P le nœud sélectionné etR le résultat de la simulationRésultat : La remontée des poids dans l’arbre

1 Début2 tant que non(estRacine(P)) faire3 N ←− nombre de passages dans le nœud P;4 M←− valeur cumulée du nœud P;5 N ←− N+1;6 si Joueur = PremierJoueur alors7 P ←− P+R;8 sinon9 P ←− P−R;

10 P ←− père(P)

11 Fin

3.3.3 Conclusion

Dans [CM10], [GW06] et [CM07], les auteurs présentent des modifications d’UCT. La méthode UCT

a été très prometteuse dans le jeu de go : elle a permis à l’ordinateur de battre des joueurs professionnels,avant cela, ce n’était pas possible. Aujourd’hui, la plupart des jeux implémente cette IA. Voici quelquesréférences :

− Sur le jeu de go : [GW06] ;

− Le programme battant des joueurs professionnels au go (Mogo) : [CTL06] ;

− Sur un jeu de carte allemand (Doppelkopf) : [Sil12] ;

− Pour d’autres jeux qui implémentent UCT : [Sen14].

Ce chapitre nous a montré une manière de traiter le dilemme Exploitation / Exploration que nous ren-controns dans le problème SAT, plus précisément dans la création d’interprétation partielle (cube) pourSAT. L’idée est donc d’utiliser l’algorithme UCT à cette fin : ce que représente le chapitre 5.

33


34

Contribution

35

Chapitre 4

Une méta-heuristique des coloniesd’abeilles butineuses pour SAT

Sommaire

4.1 Une méta-heuristique massivement parallélisable . . . . . . . . . . . . . . . . 37

4.1.1 Le choix du comportement à adopter . . . . . . . . . . . . . . . . . . . . 37

4.1.2 La communication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

4.1.3 Hiérarchie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

4.2 Déroulement de l’algorithme mémétique . . . . . . . . . . . . . . . . . . . . . 39

4.3 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

COMME dans beaucoup d’autres problèmes, SAT peut être résolu via le biais d’algorithmes d’optimi-sations (Recherche locale, recherche Tabou, ...). Grâce à une adaptation face au problème concerné,

nous retrouvons une recherche de solutions qui tend vers un optimum. Ainsi nommées méta-heuristiques,ces méthodes se comportent comme des algorithmes de recherche, tentant d’apprendre les caractéris-tiques d’un problème afin d’en trouver une approximation de la meilleure solution. Elles peuvent êtreclassées suivant leurs idéologies, on distingue ainsi les algorithmes mémétiques s’inspirant souvent dela nature (algorithme de colonie de fourmis, de colonie d’abeilles, évolutionniste, génétique, ...). Cechapitre a pour vocation de vous présenter notre approche visant à exploiter les méta-heuristiques descolonies d’abeilles dans le contexte de SAT. Tout d’abord, nous expliquons quelles sont les interactionsque nous avons choisies chez les abeilles pour notre intégration au problème SAT. Après une explicationsur le type de communication choisi au sein de notre méthode mémétique, nous discutons de chaquetâche à l’intérieur de celle-ci. Pour finir, nous expliquons le déroulement de notre méthode ainsi que lestravaux à effectuer pour aboutir à nos buts. Nous adaptons donc notre approche en mimant au mieux pos-sible ces hyménoptères pour ainsi fournir un socle théorique solide guidant une parallélisation massivepour SAT.

Signalons que ce chapitre n’est pas un état de l’art sur les colonies d’abeilles. Ainsi, le lecteur inté-ressé pourra se référer à [BOT07] qui dispose d’une liste complète des méta-heuristiques des coloniesd’abeilles puis à [KA09] proposant une analyse de divers algorithmes.

36

4.1. Une méta-heuristique massivement parallélisable

4.1 Une méta-heuristique massivement parallélisable

4.1.1 Le choix du comportement à adopter

Plusieurs comportements ont été étudiés et associés à l’algorithmique dans la littérature, mimantchacun un aspect des colonies d’abeilles, trois principales catégories sont apparues :

− le comportement des abeilles au niveau du butinage des fleurs (Foraging Behaviours) ;

− le comportement au niveau de leur reproduction (Mariage Behaviours)

− le concept de la reine des abeilles (Queen bee concept).

Nous nous focalisons sur le premier aspect, les abeilles butineuses, qui comparé au problème SAT,comporte plusieurs similitudes. D’un côté, une fleur à butiner peut être vue comme une interprétationpartielle, étant une conjonction de littéraux, une telle interprétation est nommée un cube. Puis, d’un autrecôté, le travail effectué sur un cube par un solveur est attribué au rôle d’une abeille butineuse : elle œuvresur la fleur tout comme un solveur travaille sur un cube. A présent, nous allons étudier la communicationdans notre méta-heuristique.

4.1.2 La communication

Dans le but de construire un algorithme massivement parallèle avec un modèle de programmationDRAM, sur une architecture NoRMA. Nous comparons ici, la communication des abeilles de miel aveccelle de l’ordinateur : l’échange de messages. Dans les études du monde vivant, une abeille communiqueà d’autres abeilles des informations importantes sur les sources de nectar (les fleurs) via une chorégraphieappelée la danse frétillante des abeilles (Waggle Dance). Cette danse apporte trois grandes informationsaux observateurs :

− Le temps de la danse correspond à la distance de la fleur ;

− L’intensité du frétillement correspond à la quantité de nectar présent dans la fleur ;

− La direction de la danse par rapport au soleil correspond à la direction de la fleur.

D’une même manière, nos solveurs peuvent échanger des informations, grâce à de simples échangesde messages sur l’avancée d’une résolution en cours. Un solveur peut donc mimer le comportement d’uneabeille en incluant ses communications. Cela a l’avantage d’être parallélisable sur une grande échellepar nature, de plus, notre contrainte due à l’architecture NoRMA d’échanger des petits messages estrespectée. Ainsi, après une telle danse, d’autres abeilles vont aider à récupérer le nectar. Cette assistancepeut être vue comme l’ajout d’un nouveau solveur sur le cube en question, d’une manière concurrentielleet/ou collaborative. Dans la prochaine section, nous allons voir que les méta-heuristiques des coloniesd’abeilles butineuses sont affinées suivant leurs fonctionnalités.

4.1.3 Hiérarchie

Les colonies d’abeilles ont une hiérarchie graduelle permettant d’attribuer une tâche bien précise àchaque abeille. Nous utiliserons donc ce modèle hiérarchique pour nos solveurs SAT. Comme pour lesabeilles butineuses, distinguons tout d’abord les solveurs avec mémoire contre ceux sans mémoire.

37

Chapitre 4. Une méta-heuristique des colonies d’abeilles butineuses pour SAT

Définition (Solveur avec mémoire, Solveur sans mémoire). Les solveurs avec mémoire possèdent unhistorique des tâches effectuées ainsi que d’autres informations, cette mémoire est donc partagée, etchaque solveur la possédant peut accéder aux informations de la mémoire des autres. Cette mémoire,ayant un coût, même chez les abeilles, s’associe donc à une population faible. Nous qualifierons ces sol-veurs d’expérimentés. A l’opposée, les solveurs sans mémoire n’ont aucun souvenir de leur fait et geste.

Avec Mémoire Sans MémoireSolveur Scout (S) Solveur Scout Expérimenté (SE )

Solveur Recrut (R) Solveur Inspecteur Expérimenté (IE )Solveur Butineur (B) Solveur Butineur Expérimenté (BE )

FIGURE 4.1 – Hiérarchie des tâches de chaque solveur SAT inspirée des colonies d’abeilles butineuses

La figure 4.1 nous montre les spécificités de ces deux types de solveurs, ou chaque rôle a été fidèle-ment inspiré des abeilles. D’un côté, les solveurs sans mémoire sont dissociés en trois catégories ayantchacune leur propre tâche et leur propre population. Nous les nommons solveurs scouts (S), recrus (R),et butineurs (B).

Définition (Solveur Scout (S)). Un solveur scout a pour but de chercher des cubes dans le problème ori-ginal le mieux possible : les cubes qu’il qualifie de meilleurs par rapport à d’autres cubes. La populationdes solveurs scout varie suivant la recherche, cela grâce à l’association d’une méta-heuristique propreà ce type de solveurs. Au début de la recherche, cette population est très élevée, par la suite, suivant laqualité de la recherche et des cubes déjà en jeu, elle diminue.

Définition (Solveur Recrut (R)). Un solveur recrut est un solveur en attente d’une danse frétillante :d’une communication de la part d’un autre solveur. Prêt à travailler dès qu’il reçoit les informationsnécessaires, il devient un solveur butineur. Au départ, un grand nombre de solveurs est en attente, laméta-heuristique associée a pour but de diminuer un maximum le nombre de solveurs recrus.

Définition (Solveur Butineur (B)). Un solveur butineur exploite un cube, qu’il a reçu de la part d’unautre solveur. Via une méta-heuristique calculant la qualité de la recherche en cours, il peut effectuertrois actions :

− Si la qualité est faible ou nulle alors il devient un solveur recrut.

− Si la qualité est normale alors il reste solveur butineur puis continue la recherche.

− Si la qualité est élevée alors il communique à d’autres solveurs le cube en question afin de fairetravailler ces solveurs sur le même sous-problème.

Un solveur butineur peut être de n’importe quel type : recherche complète ou incomplète, solveur pa-rallèle ou séquentiel. De plus, rappelons que lorsqu’une communication active un tel solveur, il peuttravailler en concurrence (sans changer le cube) ou collaborativement (en décidant de(s) nouveau(x) lit-téral(aux)).

Remarque. Estimer la qualité d’un cube, autrement dit, d’une interprétation partielle pour SAT est unprobléme difficile, une telle estimation est NP-Complet, le lecteur intéressé est invité à se reporter à l’ar-ticle [KSTW06a].

38

4.2. Déroulement de l’algorithme mémétique

D’un autre côté, nous avons les solveurs avec mémoire dits expérimentés, ils ont trois rôles possibles.Nous les nommons solveurs inspecteurs expérimentés (IE ), scouts expérimentés (SE ) et butineurs expé-rimentés (BE ).

Définition (Solveur Inspecteur Expérimenté (IE ), Solveur Scout Expérimenté (SE ), Solveur ButineurExpérimenté (BE )). Ces solveurs ont donc une mémoire partagée permettant de s’échanger des informa-tions et de connaître l’historique de chacun.

− Les solveurs inspecteurs expérimentés (IE ) contrôlent les cubes en cours de résolution, les commu-nications (les danses frétillantes), puis met à jour la mémoire partagée.

− Les solveurs scouts expérimentés (SE ) trouvent de nouveaux cubes grâce à la mémoire partagée envérifiant leur bonne qualité.

− Les solveurs butineurs expérimentés (BE )) résolvent les cubes qu’ils évaluent être les meilleurs grâceà la mémoire partagée.

La population de ces solveurs est réduite afin de ne pas encombrer le canal de communication. En effet,il ne s’agit pas là du modèle de programmation DRAM mais d’un modèle PRAM, nous l’intégrerons dansnotre méthode tout en minimisant la population des solveurs à mémoires.

Chaque type de solveur devra être associé à une heuristique spécifique à leur tâche. Une méta-heuristique globale gérera les populations de chaque solveur comme nous pouvons en retrouver danscertains algorithmes sur les colonies d’abeilles. La prochaine section présentera le déroulement de cettealgorithme mémétique.

4.2 Déroulement de l’algorithme mémétique

La figure 4.2 représente une vue globale des tâches se produisant pendant la recherche, le but estalors d’exploiter les meilleurs cubes afin de résoudre une instance SAT. Au début, seul les solveurs scoutstravaillent en cherchant les meilleurs cubes (S sur la figure). Une fois quelques cubes trouvés, ce solveurva alors communiquer (« danse pour rose » sur la figure) un cube à des solveurs recrus (R sur la figure),ils vont devenir des solveurs butineurs (B sur la figure) afin de résoudre le cube en question. Le solveurinspecteur expérimenté (IE sur la figure) met à jour la mémoire partagée tandis que le solveur scoutexpérimenté (SE sur la figure) essaye de trouver de meilleurs cubes. Par la suite, un solveur butineurexpérimenté (BE sur la figure) travaille sur le meilleur cube (la tulipe sur la figure). Plus la rechercheavance, plus les populations changent suivant des heuristiques, si la recherche est fructueuse, la présencede solveurs scouts sera diminuée. A l’inverse, quand l’état de la recherche se dégrade, une augmentationdes solveurs scouts essayera de débloquer la situation. Cette tâche sera accordée au solveur inspecteur.Nos travaux se concentrent essentiellement sur la création d’un tel solveur scout : ce qui nous amène à laconclusion de ce chapitre.

39

Chapitre 4. Une méta-heuristique des colonies d’abeilles butineuses pour SAT

FIGURE 4.2 – Déroulement de l’algorithme mémétique

4.3 Conclusion

L’algorithme de colonie d’abeilles adapté à SAT précédemment énoncé comporte de nombreusestâches qui demandent une bonne organisation des solveurs. Nous avons décidé de commencer par la créa-tion d’un solveur scout. Ce solveur générera ainsi les cubes nécessaires au bon fonctionnement de notrealgorithme mémétique. La qualité de ces cubes est importante : si les cubes sont tous insatifiables pourune instance satisfiable, c’est que nous avons généré de mauvais cubes. Estimer la qualité d’un cube estautant difficile que de résoudre l’instance initiale. Pour cela, nous avons étudié dans le chapitre 3, les mé-thodes de Monte-Carlo ainsi qu’une méthode permettant de traiter le dilemme exploitation/exploration :UCT. Nous avons adapté UCT afin de créer des cubes pour SAT : ceci sera notre solveur scout. Nous es-timerons donc la qualité des cubes pendant leur création pour guider la recherche. Le prochain chapitreexpliquera en détail cette création du cube, dans la suite de ce manuscrit, des expérimentations vérifierontla qualité de ces cubes.

40

Chapitre 5

Une adaptation d’UCT pour SAT :l’algorithme SCOUT

Sommaire

5.1 Le choix d’UCT pour générer des cubes . . . . . . . . . . . . . . . . . . . . . 42

5.2 Description de l’algorithme SCOUT . . . . . . . . . . . . . . . . . . . . . . . . 42

5.2.1 La descente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

5.2.2 La descente : Les valeurs UCB . . . . . . . . . . . . . . . . . . . . . . . 45

5.2.3 La descente : la création de nouveaux fils . . . . . . . . . . . . . . . . . 46

5.2.4 La descente : les conflits et littéraux déjà affectés . . . . . . . . . . . . . 47

5.2.5 La sélection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

5.2.6 La simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

5.2.7 La remontée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

5.3 La récupération des cubes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

5.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

LE PRÉCÉDENT CHAPITRE donne une vision précise de l’adaptation d’un algorithme mémétique re-posant sur les abeilles butineuses dans le cadre de SAT. Il se conclut par le besoin de créer un

programme possédant la spécificité de générer des cubes afin de suivre le comportement d’une abeillebutineuse de type scout. Un tel programme doit donc faire une recherche arborescente, afin de trouverplusieurs interprétations partielles en SAT. De plus, les cubes générés doivent être meilleurs que d’autres :le but est d’avoir beaucoup de cubes satisfiables dans un temps correct pour une instance satisfaisablepuis de les différencier avec un critère donné afin de les ordonner. Nous avons donc implémenté une nou-velle méthode de création des cubes pour SAT que nous nommons SCOUT pour sa représentation d’uneabeille scout.

Deux méthodes de la littérature peuvent nous donner des idées sur la conception algorithmique d’untel programme : elles ont été étudiées dans notre état de l’art au chapitre 2. La première est la méthodecollaborative appelée chemin de guidage (Guiding path) qui joue avec des interprétations partielles afinde distribuer la recherche sur les nœuds de calculs. La deuxième, nommée Cube And Conquer (CC) gé-nère des cubes exactement comme nous pourrions le souhaiter à un petit détail près, elle n’obtient pasd’ordre sur les cubes permettant de savoir si les cubes générés sont plus ou moins utiles.

41

Chapitre 5. Une adaptation d’UCT pour SAT : l’algorithme SCOUT

Nous allons tout d’abord expliquer le choix d’UCT afin de générer des cubes. Après une descriptionsur la structure des nœuds utilisée dans SCOUT, nous expliquerons, étape par étape, l’algorithme qui endécoule avec ses subtilités. Par la suite, nous parlerons des heuristiques utilisables dans notre algorithmeet celles implémentées. Pour finir, nous conclurons et étudierons les améliorations possibles.

5.1 Le choix d’UCT pour générer des cubes

Dans l’optique de choisir les meilleurs cubes dans un arbre de recherche, nous avons été confronté audilemme exploitation/exploration : faut-il exploiter un cube déjà considéré comme bon en lui rajoutantdes littéraux ou retenter notre chance avec un nouveau cube. Récemment, la naissance d’un algorithmepour les jeux à deux joueurs nommé UCT traite ce problème : exploiter un état de la partie qui sembleêtre bon, ou explorer d’autres états moins bons. Ce dilemme est très connu en intelligence artificielle,il a été abordé ainsi que l’algorithme UCT dans le chapitre 3. Cet algorithme a prouvé son efficacité enpermettant pour la première fois à une intelligence artificielle de battre un joueur humain professionneldans le jeu de Go. Néanmoins, UCT a le besoin de faire une simulation difficilement adaptable à SAT.Cependant, deux raisons essentielles nous ont poussées à choisir UCT afin de l’adapter à notre recherchede cubes par un solveur scout. La première est qu’il est capable de traiter d’une manière efficace ledilemme exploration/exploitation que nous retrouvons au niveau de la création des cubes. La deuxièmeraison vient du fait que l’algorithme UCT est utilisé dans des problèmes possédant un immense arbre derecherche, comme c’est le cas pour le problème SAT.

5.2 Description de l’algorithme SCOUT

Tout d’abord, distinguons un fait primordial à la compréhension de notre méthode SCOUT : nousavons deux arbres de recherche différents en coopération. Le premier, est celui associé à un solveur SAT

pouvant revenir à la racine de son arbre binaire, via un redémarrage. Le second est notre arbre n-aire derecherche représentant un UCT modifié pour SAT : il représente la fouille de cubes dans notre algorithmeSCOUT. Ces deux arbres sont étroitement liés via les cubes : celui représentant UCT les garde en mé-moire tandis que le solveur SAT les simule. Dans la suite de ce manuscrit, quand aucune précision n’estapportée sur la nature de l’arbre, nous considérons que nous parlons de l’arbre n-aire représentant UCT.

Comme pour la méthode UCT, notre algorithme se divise en quatre étapes, vues au chapitre 3 : ladescente, la sélection, la simulation et la remontée (figure 3.2). Ces étapes sont réitérées dans cet ordreà plusieurs reprises suivant le nombre d’itérations UCT que nous désirons appliquer. Chacune de cesétapes a été adaptée avec un solveur SAT afin de générer les cubes demandés. Après quelques informa-tions globales sur la structure de données à l’intérieur de SCOUT, nous allons adapter l’algorithme UCT

au problème SAT pour ces quatre étapes.

Les nœuds de notre arbre, excepté la racine, contiennent distinctement trois informations essen-tielles : la première est un littéral de la formule propositionnelle tandis que les deux autres proviennentde l’algorithme UCT : la moyenne pondérée du nœud par rapport à ses fils (average) et le nombre de pas-sages dans ce nœud par UCT (passing). L’attribut average est une valeur compris entre 0 et 1 exprimantla qualité d’un cube. En plus de ces attributs, chaque nœud possède deux méthodes utilisées dans l’étapede descente : calculUCB() et calculUCBspéciale(). Ces deux méthodes sont expliquées dansles prochaines sous-sections. Par contre, le nœud racine possède uniquement les attributs average et pas-

sing, ainsi qu’une seule méthode : calculUCB(). En effet, la racine n’est associé à aucun littéral. Dece fait, certaines fonctionnalités et informations ne sont pas utiles. La figure 5.1 représente un aperçu de

42

5.2. Description de l’algorithme SCOUT

notre arbre ainsi que la structure des nœuds après plusieurs itérations UCT.

FIGURE 5.1 – Structure des nœuds dans notre algorithme SCOUT.

Contrairement à l’algorithme UCT de base qui considère l’ensemble des états atteignables à chaqueouverture de nœud (il crée donc potentiellement autant de noeuds que d’états atteignables), notre al-gorithme ne considère qu’une seule une variable x lors de l’ajout d’un noeud et crée deux fils. L’unreprésente le littéral x et l’autre, son opposé ¬x. Cette solution a été choisie afin de limiter l’explosionde la taille de l’arbre considéré, nous l’expliquons en détail dans l’étape de la sélection. Le fait que l’arbresoit n-aire provient de la descente qui peut choisir un nœud contenant déjà des fils, la section 5.2.3 nousexplique en détail ce phénomène. À présent, nous allons expliquer avec minutie chaque étape.

5.2.1 La descente

Algorithme 5 : descenteScoutV1(R)Données :R la racine de l’arbre SCOUT

Résultat : Le nœud utilisé pour l’étape de la sélection1 Début2 tant que possèdeFils(R) faire3 si maxUCBSpéciale(R) alors4 retournerR;

5 SolveurSATdécide(R);6 R←− filMaxUCB(R);7 passing(R)←− passing(R)+ 1;

8 retournerR;9 Fin

La première étape provenant d’UCT a pour but de descendre dans l’arbre de recherche en choisissantpour chaque nœud parcouru, la branche maximisant les valeurs UCB de ses fils (via calculUCB())ou la valeur UCB spéciale (via calculUCBspéciale()). L’algorithme 5 représente une premièreversion de la descente que nous affinerons dans la suite de ce manuscrit. Tant que le nœud courant n’estpas une feuille (ligne 2), l’algorithme descend dans le fils possédant la valeur UCB (calculUCB()) la

43


plus grande (ligne 6). Nous avons deux cas d’arrêts dont un dans cette boucle. Ce premier, nous dit quesi la valeur UCB spéciale est plus grande que les valeurs UCB des fils (ligne3), alors nous retournons lenœud en cours. Tandis que le second arrive une fois que nous sommes arrivés sur une feuille de l’arbre.A chaque fois que nous descendons dans un nœud, un solveur SAT associé à notre algorithme SCOUT

affecte comme variable de décision le littéral en question (ligne 5) et effectue aussi les propagationsunitaires possibles. À présent, nous allons voir sur un exemple concret ces deux cas d’arrêts via la figure5.2.

(a) Arrêt normal (b) Arrêt via la valeur UCB spécial

FIGURE 5.2 – La descente dans notre algorithme SCOUT

Exemple. Cette figure se décompose en deux sous-figures : à gauche (sous-figure 5.2a), nous retrouvonsle retour normal (ligne 15 de l’algorithme 5) tandis que sur notre droite (sous-figure 5.2b), nous avons leretour à l’intérieur de la boucle (ligne 4).

La première sous-figure (sous-figure 5.2a) nous montre une situation où la valeur UCB spéciale n’estjamais plus grande que les valeurs UCB des fils. Sur la sous-figure de gauche, nous comparons la valeurUCB spéciale (0.106) avec les valeurs UCB des fils (0.113,0.112,0.115,0.126,0.090,0.106) de la racine. Laplus grande valeur étant celle du nœud possédant le littéral ¬x2 (0.126), nous réitérons la descente sur cenœud qui n’est pas une feuille. Itérativement, nous continuons de descendre dans les nœuds représentéspar les littéraux x6, x3 et ¬x5. Ce dernier étant une feuille, la descente renvoie ce nœud. Pendant cettedescente, le solveur SAT associé effectue donc les décisions suivantes ¬x2, x6, x3 et ¬x5.

44


La seconde sous-figure (sous-figure 5.2b) nous montre le cas d’arrêt via la valeur UCB spéciale.Comme précédemment, la plus grande valeur est celle du nœud ¬x2 (0.126), nous suivons donc cedernier. Par la suite, nous comparons la valeur UCB spéciale (0.312) avec les valeurs UCB des fils(0.712,0.678) du nœud ¬x2. Le nœud représentant le littéral x6 (0.712) est donc choisi. Toujours dela même manière, nous comparons la valeur UCB spéciale du littéral x6 (0,950) avec les valeurs UCB deses fils (0.878,0.700). Cette fois-ci, c’est la valeur UCB spéciale qui est la maximale. L’algorithme ren-voie donc le nœud représenté par le littéral x6. De plus, le solveur SAT associé effectue donc les décisionssuivantes ¬x2 et x6.

La valeur UCB spéciale permet de générer des arbres n-aires car elle arrête la descente sur un nœudqui en contient déjà des fils. Nous en reparlerons dans la section 5.2.3.

5.2.2 La descente : Les valeurs UCB

Pour bien comprendre UCB dans SCOUT, nous ne parlerons pas dans cette sous-section des valeursUCB spéciales (5.2.3). Nous choisissons de calculer les valeurs UCB des fils via une adaptation de l’équa-tion 3.1. Ce calcul est réalisé par la méthode calculUCB. Nous avons choisi l’adaptation suivante.Lorsque passing > 0, l’indice UCB associé au nœud i est :

UCBi = averagei︸︷︷︸

Terme Exploitation

+ K ∗

√

ln(passingpere(i))

passingi︸︷︷︸

Terme Exploration

(5.1)

Nous avons réglé la valeur K à 0.009, ce réglage est dû à la moyenne choisie ainsi qu’à la naturedu problème pour un nœud. Or, chaque nœud a des fils qui différent, représentant donc des problèmesdistincts. Chaque nœud devrait calculer les valeurs UCB de ses fils avec son propre réglageK. Autrementdit, il ne faut pas que K diffère suivant les fils d’un père, mais qu’il se distingue par rapport au nœudchoisi lors de la descente.

FIGURE 5.3 – Calcul des valeurs UCB dans SCOUT

Exemple. La figure 5.3 représente le choix de la branche à choisir pour descendre dans l’arbre : le nœudqui a le plus grand UCB. Pour chaque fils i du nœud racine, la valeur UCBi est calculée suivant ce tableauen prenant K à 0.009. De plus, passingpere(i) = 50 est le nombre d’itérations UCT à cet instant.

45


Littéral passing average Terme Exploration UCBi

x2 10 0.108 0,005629155 0,113629155¬x2 5 0.105 0,007960827 0,112960827x4 15 0.111 0,004596186 0,115596186¬x4 7 0.120 0,006728127 0,126728127x1 10 0.085 0,005629155 0,090629155¬x1 8 0.100 0,006293587 0,106293587

Nous remarquons que le terme exploration varie principalement en fonction de passing et de la va-riable K : plus passing est élevé, plus le terme exploration devient petit. De même, plus le nombred’itérations UCT est grand, plus ce même terme diminue, cela permet de tendre pendant la recherche versune exploration nulle. Dans notre exemple, la variableK est trop petite, elle devrait s’ajuster dynamique-ment suivant l’écart des moyennes. Une variable K mal réglée nous donne un terme d’exploration troppetit pour avoir un impact sur la recherche. Cette valeur devrait donc dans l’idéal s’adapter dynamique-ment. Nous reparlerons de ce réglage dans le chapitre 6.

5.2.3 La descente : la création de nouveaux fils

L’étape de la descente peut nous renvoyer un nœud pour la sélection dans deux situations différentes.Rappelons que pour chaque nœud, nous descendons dans le fils ayant la plus grande valeur UCB associée,ou nous sélectionnons la valeur UCB spéciale. Cette valeur spéciale représente un autre dilemme explora-tion/exploitation et est calculée par la méthode calculUCBspéciale(). L’étape de la descente peuts’arrêter si la valeur UCB spéciale est plus grande que celle des fils. Remarquons que même la racinepeut calculer cette valeur UCB spéciale via la méthode calculUCBspéciale(). L’idée derrière cettefonctionnalité est de pouvoir diversifier les cubes. On peut à présent créer dans notre arbre un nouveaucube qui commence par un littéral différent : sans cette valeur UCB spéciale, cela n’est pas possible. Cetajout permet d’avoir un arbre n-aire car il crée lors de l’étape de la sélection des fils sur un nœud qui encontient déjà. Nous voulons beaucoup de cubes, qui se ressemblent le moins possible. Et nous voulonséviter le plus possible d’avoir des cubes inclus dans d’autres, ce que nous appellerons sous-cubes par lasuite.

Le dilemme n’est plus le même : faut-il ajouter à un nœud des nouveaux fils (pour explorer) ouexploiter ceux déjà présents ? Nous adaptons l’équation 3.1 pour calculer la valeur UCB spéciale. Nousne considérons plus le nombre de passages dans le nœud (passing) mais le nombre de fils que nousavons. Moins nous avons de fils, plus la valeur UCB spéciale sera grande, augmentant alors la possibilitéd’explorer.

UCBspeciali = averagei

︸︷︷︸

Terme Exploitation

+ K ∗

√

ln(passingi)

nbFils︸︷︷︸

Terme Exploration

(5.2)

Notons tout de même que cette UCB spéciale a dû être multipliée par une constante afin de l’associeraux autres valeurs UCB. Retenons que pour un nœud, nous calculons donc les valeurs UCB de ses fils puisla valeur UCB spéciale de ce nœud pour récupérer la valeur qui maximise toutes les autres. Si la valeurmaximale appartient à un fils, nous descendons dans ce fils, sinon nous nous arrêtons sur ce nœud pourpasser à l’étape de la sélection.

46


Algorithme 6 : descenteScoutV2(R)Données :R la racine de l’arbre SCOUT

Résultat : Le nœud utilisé pour l’étape de la sélection1 Début2 tant que possèdeFils(R) faire3 si maxUCBSpéciale(R) alors4 retournerR;

5 SolveurSATdécide(R);6 F ←− filMaxUCB(R);7 si estConflit(F) ou déjàAffectéValeurOpposée(F) alors8 supprime(F);9 remontée(R);

10 return NULL;

11 si déjàAffectéMêmeValeur(F) alors12 supprime(¬F);

13 passing(R)←− passing(R)+ 1;14 R←− F ;

15 retournerR;16 Fin

5.2.4 La descente : les conflits et littéraux déjà affectés

L’algorithme 6 ajoute des cas particuliers à l’algorithme général 5. Tout d’abord, le solveur associéredémarre en gardant les clauses apprises : il est donc à la racine de son arbre de recherche et n’a encoredécidé d’aucun littéral. Rappelons qu’à chaque descente dans l’arbre, le solveur SAT associé effectue despoints de choix (variables de décisions associés au nœuds choisis) et les propagations unitaires qui enrésulte. A partir de là, plusieurs cas peuvent survenir :

− Un conflit survient ;

− Le solveur essaie d’affecter un littéral qui l’est déjà ;

− Aucun des deux cas précédents ne survient, et le solveur SAT se retrouve dans un état fixe, tel qu’ille serait avant un point de choix.

✕

FIGURE 5.4 – Conflit ou littéral déjà affecté à une valeur opposée lors de la descente dans notre algo-rithme SCOUT

Dans le cas d’un conflit, le solveur SAT analyse ce dernier et apprend une nouvelle clause. De plus,nous élaguons simplement le nœud en question dans l’arbre UCB (figure 5.4 et ligne 7 de l’algorithme).

47


En effet, ce nœud amenant à un conflit génère un cube inutile car inconsistant. De plus, nous remontonsalors les poids de l’arbre UCB comme dans l’étape de la remontée (sous-section 5.2.7). Par la suite, nouspassons simplement à une nouvelle itération UCT. Si un littéral est déjà affecté, nous avons deux situa-tions possibles : soit ce littéral est affecté à une valeur égale à celle présente dans notre arbre, soit à sonopposé.

FIGURE 5.5 – Littéral déjà affecté lors de la descente dans notre algorithme SCOUT

Dans le premier cas, nous élaguons simplement le nœud représentant le littéral opposé dans le mêmeniveau de l’arbre s’il est présent (figure 5.5 et ligne 11 de l’algorithme). Dans le second cas, nous éla-guons ce nœud comme pour un conflit (figure 5.4 et ligne 7 de l’algorithme), puis nous faisons uneremontée des poids. En réalisant ce traitement, nous nous assurons de ne pas retomber sur ce mêmenœud à la prochaine itération UCT. Rappelons que dans les cas où nous supprimons un nœud, nous redé-marrons le solveur et notre algorithme, cela correspond respectivement à un redémarrage à la racine del’arbre binaire pour le solveur en gardant les clauses apprises et au passage de la prochaine itération UCT

pour notre algorithme SCOUT. Il en va de soi que lorsque nous élaguons un tel nœud, nous supprimonsrécursivement tous ses descendants.

Une amélioration possible est de ne pas remonter le poids des nœuds. Ce fait nous permet de nepas revenir à la racine de notre arbre mais de continuer à choisir un autre littéral pour descendre. Onaccorderait alors à une itération UCT de faire son travail complètement afin de passer à l’étape de la sé-lection. Cela sans devoir retourner au début d’une itération UCT par la faute d’un conflit ou d’un littéraldéjà affecté. On éviterait par là-même un travail inutile au solveur en supprimant le redémarrage de cedernier. En contrepartie, la descente serait quelque peu faussée, car les poids n’auraient pas été mis à jour.

5.2.5 La sélection

La figure 5.6 nous montre deux ajouts de nœuds différents : à gauche (sous-figure 5.6a), nous avonsun ajout standard sur une feuille de l’arbre tandis que sur la droite (sous-figure 5.6b), nous avons unajout sur un nœud possédant déjà des fils. Ce dernier ajout est dû à notre valeur UCB spéciale calculéedurant la descente. Cette figure montre la sélection d’une variable suivant la descente représentée par lafigure 5.2. Cette étape demande simplement au solveur SAT associé de lui fournir une nouvelle variable àajouter dans l’arbre UCB sur le nœud choisi. Nous avons choisi d’utiliser l’heuristique VSIDS utilisé parles démonstrateurs CDCL (sur l’exemple de la figure 5.6, la variable xn a été choisie). Nous avons utilisél’heuristique VSIDS basée sur l’activité des conflits, pour choisir la prochaine variable à ajouter lors del’étape de la sélection. Cette heuristique guide la recherche vers les conflits afin d’essayer de se focalisersur une partie difficile du problème. Nous espérons ainsi récolter des cubes les plus utiles possibles. Encontrepartie, nous pouvons générer plus de conflits (voir figure 5.4) et réduire ainsi le nombre de cubes

48


(a) Arrêt normal (b) Arrêt via la valeur UCB spécial

FIGURE 5.6 – La sélection dans notre algorithme SCOUT

générés. Contrairement à nous, la méthode Cube And Conquer (CC) expliquée au chapitre 2 utilise uneheuristique de type look-ahead : la variable choisie est celle produisant le plus de propagations unitaires.L’utilisation d’une telle heuristique est une de nos perspectives de travail.

5.2.6 La simulation

La simulation a pour but de calculer la première valeur (average) au(x) nœud(s) venant d’être sélec-tionné(s). Une telle simulation va donc être faite sur le cube représenté par les littéraux du chemin de laracine de l’arbre à ce nœud. Elle doit évaluer la qualité de ce cube (plus le cube est supposé intéressant,plus la valeur average du noeud est proche de 1). Différents travaux ont été réalisés ces dernières annéespour évaluer la taille d’un arbre de recherche [KSTW06b]. Dans un premier temps, nous avons choisipour première heuristique de simulation de prendre tout simplement le nombre de littéraux assignés aumoment de la simulation d’un cube. Elle a l’avantage d’être simple et rapide, mais a pour inconvénientmajeur de n’être pas assez précise sur la qualité d’un tel cube. Les tests effectués avec cette heuristique,pourront servir de base dans le futur. Nous prévoyons des simulations en faisant appel à des solveurs enparallèle qui seront beaucoup plus précises.

49


FIGURE 5.7 – La remontée dans notre algorithme SCOUT

5.2.7 La remontée

Lorsque un nœud a été créé, nous avons calculé la valeur average via la simulation expliquée dans lasection précédente. Il nous faut maintenant propager cette valeur sur les nœuds ascendants, et ce, jusqu’àla racine de l’arbre UCT. Cela est schématisé dans la figure 5.7. Lors du choix de la variable xn, nousavons donc en règle générale deux nœuds xn et ¬xn. Nous calculons alors une nouvelle valeur averagepour ¬x5, puis x3 et ainsi de suite jusqu’à la racine (dans le cas où nous avons créé des nouveaux fils(voir section 5.2.3), le même processus est réalisé).

5.3 La récupération des cubes

Une fois un bon nombre total d’itérations UCT effectuées, nous trions les cubes via leur moyenne dansl’arbre (average). Il existe de nombreuses méthodes dans la littérature pour récupérer les chemins de laracine aux feuilles dans un arbre n-aires. Plusieurs méthodes sur des arbres binaires sont représentéesdans l’article [MdWH14]. L’algorithme 7 illustre notre méthode, elle se contente de prendre le cubecontenant la meilleure moyenne (ligne 4 à 6) puis d’effacer la feuille en question. Quand nous effaçonscette feuille, nous effaçons aussi récursivement ses ascendants quand ils deviennent des feuilles (ligne 8à 11). Nous réitérons ce procédé afin de récupérer les cubes par rapport à leur moyenne. Nous obtenonsdonc notre ordre sur les interprétations partielles.

50

5.4. Conclusion

Algorithme 7 : récupCube(R)Données :R la racine de l’arbreRésultat : C l’ensemble ordonné des cubes récupérés

1 Début2 tant que possèdeFils(R) faire3 N ←− R;4 tant que possèdeFils(N) faire5 N ←− filMaxUCT(N);

6 C ←− C ∪ récupCubeFeuille(N);7 P ←− père(N);8 tant que possèdeUnSeulFils(P) faire9 delete(N);

10 N ←− P;11 P ←− père(P);

12 retourner C;13 Fin

5.4 Conclusion

Nous avons exposé une nouvelle méthode de construction de cubes pour SAT nommée SCOUT. Notreméthode a l’originalité de s’attaquer pour la première fois à ce problème en utilisant l’algorithme UCT,qui tente de trouver un bon compromis entre l’exploitation et l’exploration. De plus, cette méthode aété faite dans le but de créer un solveur massivement parallèle grâce à l’utilisation de méta-heuristiquesur les colonies d’abeilles butineuses. La méthode SCOUT respecte donc très bien son rôle. Par la suite,les cubes contenus dans notre arbre représenté par la méthode SCOUT seront encore plus affinés par desabeilles butineuses. Ces solveurs pourront améliorer la qualité de cet arbre (figure 5.8).

FIGURE 5.8 – Affinage de l’arbre de SCOUT par un algorithme de colonie d’abeilles

51


Beaucoup d’améliorations sont possibles dans notre algorithme, notamment au niveau des heuris-tiques choisies. En effet, il est préférable de tester plusieurs heuristiques pour ainsi sélectionner lameilleure : cela est un but pour d’autres projets. Une amélioration possible est de transformer notreméthode en utilisant la puissance de la parallélisation, afin d’affiner les simulations faites dans SCOUT.Par ailleurs, il se trouve que les méta-heuristiques des colonies d’abeilles n’utilisent pas tous les cœursau début de la recherche, ces cœurs pourraient donc servir à notre méthode SCOUT. La partie UCB denotre algorithme peut être grandement améliorée, en effet, nous verrons dans le chapitre suivant qu’ilest difficile de régler ces valeurs UCB, et qu’un réglage statique ne suffit pas. La création des fils spé-ciaux hérite aussi ce problème car elle est basée sur une valeur de type UCB. Dans le chapitre suivant,nous allons voir les résultats des tests effectués sur notre méthode ainsi que quelques détails concernantl’implémentation.

52

Chapitre 6

Résultats

Sommaire

6.1 Le programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

6.2 Expérience sur les variables des cubes . . . . . . . . . . . . . . . . . . . . . . 54

6.3 Expérimentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

6.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

LE PROGRAMME nommé SCOUT a été développé en C++. Nous avons pris pour base le solveurMINISAT V2 [SE02] qui offre plusieurs avantages. Tout d’abord, il est aussi développé en C++ sim-

plifiant par la-même la mise en oeuvre. Très bien écrit et très bien documenté, il contient de plus toutesles fonctionnalités d’un solveur moderne (propagation unitaire, VSIDS, ...) utiles pour notre SCOUT. Mal-gré tout, notre programme est modulaire (héritage, interface...) et il est extrêmement facile d’interfacerun autre solveur SAT dans la mesure où celui-ci est adapté pour évaluer une interprétation partielle.

Tout d’abord, nous exposerons notre programme et les interfaces utilisées. Ensuite, nous allons dé-crire les résultats d’une expérience visant à savoir si nos cubes sont assez diversifiés. Puis, nous don-nerons des informations sur les cubes (sous-cubes, temps de génération, ...). Après avoir exposé desrésultats basés sur sept instances, nous allons conclure ce chapitre.

Nous avons sélectionné sept instances satisfiables issues de la compétition SAT 2013 pour nos expé-rimentations. Notre objectif est de tester les cubes créés par notre méthode SCOUT pour ces instances.Ces expérimentations permettront d’avoir une idée sur la qualité des cubes.

6.1 Le programme

Le programme SCOUT a été développé sur une interface nommée IMainSimulatorSolver etdéfinie comme l’union de deux interfaces : ISolver et ISimulator. La première définit les méthodesutiles au solveur SAT principal accompagnant la descente ainsi que la sélection de notre algorithme tandisque la seconde accompagne un solveur SAT permettant de simuler un cube. Par exemple, il est donc pos-sible d’adapter séparément un solveur de recherche locale afin de faire l’étape de simulation et d’utiliserun solveur standard pour les autres étapes, et vice-versa. Il faut tout de même programmer les interfacesen question. Comme nous l’avons déjà dit, nous avons choisi d’utiliser MINISAT. lDans cette étude ex-périmentale, nos tests sont uniquement basés sur l’heuristique VSIDS pour le choix de variables lors de

53

Chapitre 6. Résultats

la sélection et sur la propagation unitaire pour la simulation.

Une fois que le programme a fini son exécution sur une instance donnée, un fichier .cubes portantle nom de l’instance est créé. Ce fichier contient toutes les interprétations partielles générées dans unordre suivant la moyenne (average) de chaque nœud de notre arbre de recherche SCOUT (voir section5.3). La figure 6.1 représente un tel fichier dans lequel le nombre de la première ligne est le nombre decubes.

CUBES 5085

3628 -3657 -597 1464 -3606 -1450 3631 3673 -3676 0

3628 -3657 -597 1464 -3606 -1450 3631 3673 3676 0

3628 -3657 -597 1464 -3606 -1450 3631 -3673 0

FIGURE 6.1 – Fichier .cubes

Pour pouvoir effectuer nos tests , nous avons modifié un solveur MINISAT afin de le rendre capablede charger un cube : une ligne d’un fichier .cubes. Le solveur en question affecte les littéraux présentssur la ligne d’un fichier .cubes donnée en paramètre et effectue aussi les propagations unitaires pos-sibles. Le solveur affecte chaque littéral du cube en les considèrant comme des hypothèses, comme celaest fait en SAT incrémental [ALS13]. Une fois l’ensemble des littéraux du cube affectés, le solveur secomporte comme un solveur classique. Afin de réaliser nos expérimentations, nous utilisons plusieursprogrammes :

− Le programme SCOUT ;

− Un programme qui charge un cube afin de le résoudre ;

− Un programme comptant le nombre de sous-cubes dans un fichier .cubes ;

− Un programme comptant le nombre d’occurrence des variables dans un fichier .cubes.

6.2 Expérience sur les variables des cubes

Les figures 6.2, 6.3 et 6.4 nous montrent pour nos sept instances combien de fois chaque variable estapparue dans les cubes. Afin de mieux diversifier ces variables, nous avons augmenté la graine aléatoirede l’heuristique VSIDS. Les résultats associés nous montrent alors une diversification convenable. Eneffet, la plupart des variables apparaissent que très peu de fois, et seul un petit pourcentage d’entreelles apparraissent dans la majorité des cubes. Ceci est un peu moins vrai pour les instances 003 etaes641keyfind1. Le défaut de ces deux instances est dû au nombre de variables totales (respectivement4128 et 596 variables) qui est petit par rapport aux autres instances. En effet, elles possèdent un petitnombre de variables mises en jeu dans les cubes (respectivement 23 et 69 variables).

54

6.2. Expérience sur les variables des cubes

V ariables

Apparitions4830

23

(a) 003 : 72259 clauses et 4128 variables

V ariables

Apparitions4918

69

(b) aes641keyfind1 : 2632 clauses et 596 variables

V ariables

Apparitions910

348

(c) bob12m06 : 1369224 clauses et 482635 variables

V ariables

Apparitions1266

205

(d) pb20003lb03 : 311884 clauses et77289 variables

FIGURE 6.2 – Nombre de variables dans les cubes (partie 1)

55


V ariables

Apparitions4041

607

(a) pb30001lb00 : 595953 clauses et 140866 variables

V ariables

Apparitions4846

345

(b) pb30002lb06 : 630463 clauses et 148565 va-riables

FIGURE 6.3 – Nombre de variables dans les cubes (partie 2)

V ariables

Apparitions4931

319

FIGURE 6.4 – Nombre de variables dans les cubes (partie 3) : UTI-20-5p1 : 1195016 clauses et 225926variables

6.3 Expérimentation

A cause d’un trop grand nombre de cubes (environ 5000 pour chaque instance), il est difficile detester tous ces cubes sur un cluster car cela prendrait trop de temps. Nous avons donc choisi de limiterle nombre de cubes à tester. De ce fait, sur ces sept instances, nous avons testé les 100 meilleurs cubespuis 100 autres cubes répartis au hasard parmi les autres. Nous avons exécuté notre programme SCOUT

sur 5000 itérations UCT, puis sur 20000 itérations UCT. Nous discuterons uniquement des tests effectuéssur 5000 itérations UCT sachant que ceux sur 20000, nous apportent à peu près les mêmes résultats. Toutd’abord, la figure 6.5 nous présente des informations sur la création des cubes effectuée par notre pro-gramme SCOUT.

la colonne « Cubes » présente le nombre de cubes générés tandis que la colonne « % de sous-cubes »

56

6.3. Expérimentation

Instances Clauses Variables Cubes % sous-cubes UCB Conflits Fils Spéciaux003 72259 4128 5085 47 Explore souvent 41 116

aes641keyfind1 2632 596 4918 10 Bien 70 22bob12m06 1369224 482635 8512 8 Fait qu’explorer 75 3644

pb30001lb00 595953 140866 4297 0.16 Bien 412 5pb30002lb06 630463 148565 4936 1.05 Bien 54 19pb20003lb03 311884 77289 1348 0 Bien 2088 27

UTI205p1 1195016 225926 4933 0.16 Bien 70 7

FIGURE 6.5 – Information sur la création des cubes.

est le pourcentage du nombre de cubes étant sous-cubes parmi les cubes (un sous-cube est un cube inclusdans un autre). Un programme indépendant s’occupe de vérifier ce pourcentage pour une instance don-née. Ce pourcentage est correct sauf pour l’instance 003. En effet, les résultats de la section précédenteont montré que cette instance possède dans ces cubes, un trop petit nombre de variables mises en jeu.Les résultats de la colonne « % de sous-cubes » confirme les résultats de la section précédente.

Par la suite, la colonne « UCB » nous dit si l’arbre de cube généré par notre programme a été construitsur des valeurs UCB bien réglées. C’est à dire, à quel point l’étape de la descente préfère exploiter un cubede qualité ou explorer un autre cube moins bon. Pour avoir cette information, nous regardons l’attributpassing de chaque nœud de l’arbre. En effet, pour une profondeur donnée de l’arbre, plus les attributspassing des nœuds sont égaux, plus nous explorons d’autres cubes. Par contre, toujours pour une profon-deur donnée, si l’algorithme de l’étape de la descente est toujours passée (passing) dans le même nœud,c’est qu’il n’a fait qu’exploiter ce nœud. Quand nous marquons « bien » dans une case de cette colonne,c’est que les valeurs UCB sont bien réglées. Dans ce cas, l’algorithme n’explore ou n’exploite jamais tousle temps un nœud, mais trouve un compromis. Nous pouvons donc conclure que deux instances ont unUCB mal réglé (003 et bob12m06).

La colonne « Conflits » est le nombre total de conflits rencontrés, on peut remarquer qu’il est assezfaible. Cela est dû à l’exploration qui empêche l’heuristique VSIDS d’appliquer correctement sa tâche(orienter la recherche vers les conflits). Le nombre de fois que nous ajoutons de nouveaux fils sur un nœudqui en possède déjà est le nombre de fils spéciaux de la dernière colonne : ce nombre est proportionnelà l’exploration de la recherche. En effet, plus il est élevé, plus l’arbre de recherche a été exploré plutôtqu’exploité. À présent, la figure 6.6 nous montre les résultats des 200 cubes testés sur chaque instance.

Instance NbCube SAT NbCube UNSAT NbCube TIMEOUT003 117 0 83

aes641keyfind1 0 196 4bob12m06 0 183 17

pb30001lb00 21 37 142pb30002lb06 1 139 60pb20003lb03 11 188 1

UTI205p1 0 200 0

FIGURE 6.6 – Résultat : Informations sur tous les cubes.

Notons que le timeout est de deux heures et rappelons que ces sept instances proviennent de la com-

57


pétition SAT 2013. Nous avons donc quatre instances sur les sept qui nous ont donné des cubes satisfiablesparmi les 200 cubes choisis. Ces résultats pourront être comparés avec de futures versions de notre pro-gramme : d’autres heuristiques. Ne ne pouvons pas comparer ces résultats avec d’autres méthodes carnotre méthode SCOUT n’est pas un solveur SAT. Néanmoins, nous espérons avoir plus de cubes satis-fiables en changeant les heuristiques. Pour nous donner une idée sur la qualité des cubes satisfiables, lafigure 6.7 nous donne des informations sur les cubes satisfiables.

Instance Moyenne Temps CPU Moyenne % Assigné Moyenne Taille003.log 2950.52s 0% 8.15

aes641keyfind1 - - -bob12m06 - - -

pb30001lb00 313.02s 9% 14.57pb30002lb06 45.75s 0% 6pb20003lb03 66.98 2% 5.27

UTI205p1 - - -

FIGURE 6.7 – Information sur les cubes uniquement satisfiables.

La colonne « Moyenne Temps CPU » est le temps moyen CPU de la résolution des cubes satisfiables.La colonne « Moyenne % Assigné » est la moyenne des variables assignées des cubes satisfiables tandisque « Moyenne Taille » représente les longueurs en moyenne. Afin de se faire une idée plus précise surla qualité des cubes, nous allons analyser le meilleur des cubes (en temps CPU) pour chaque instance.

Instance Numéro Taille Assignement % Assignement Temps MINISAT Temps création Temps résolution003 34 8 4 0% 1492.15s 0.26s 62.22s

aes641keyfind1 - - - - 94.83s 0.05s -bob12m06 - - - - TIME OUT 2h 7.71s -

pb30001lb00 428 11 10312 7% 17.10s 22.56s 1.95spb30002lb06 4660 6 1170 0% 4.97s 12.4s 45.75spb20003lb03 69 6 2036 2% 13.48s 4.81s 3.15s

UTI205p1 - - - - 732.63s 11.21s -

FIGURE 6.8 – Informations sur le meilleur cube satisfiable uniquement.

La figure 6.8 nous donne d’autres informations. Si une instance ne possède aucun cube satisfiable surles 200 testés, nous le signalons par un tiret. Le « Temps MINISAT » est présent à titre de comparaison,c’est le temps de MINISAT sur l’instance initiale. La colonne « Temps Création » est le temps de créa-tion des cubes sur l’instance par notre programme SCOUT. La colonne « Temps Résolution » représentele temps de résolution du premier cube satisfiable. La colonne « Assignement » montre le nombre devariables assignées par le cube. En général, le meilleur cube ne rivalise pas avec MINISAT, sauf pourles instances pb20003lb03 et 003. Ces expériences sont un moyen de comparer les heuristiques de notreprogramme SCOUT dans le futur.

La figure 6.9 s’intéresse à l’ordre des cubes. Nous espérons voir si les cubes satisfiables sont enmajeure partie dans les 100 premiers cubes ou, au contraire, dans les 100 pris aléatoirement. Or, cesrésultats nous montrent qu’ils sont un peu partout. Une solution serait de faire des tests sur une plusgrande quantité de cubes.

58

6.4. Conclusion

003.log : 4 5 6 7 8 10 11 14 15 18 19 22 23 24 26 27 30 33 34 35 38 40 41 42 44 45 49 50 51 52 53 5559 60 63 66 69 70 71 73 74 75 76 77 80 81 83 87 94 95 96 97 98 100 149 247 345 394 443 492 639 688737 835 933 1031 1080 1178 1227 1325 1374 1423 1521 1619 1668 1815 1864 1962 2011 2109 21582207 2256 2452 2550 2599 2648 2746 2795 2893 3040 3089 3187 3236 3285 3334 3383 3530 35793628 3677 3726 3775 3824 3873 3922 4069 4118 4265 4314 4412 4559 4804 4902 4951 5000pb30001lb00 : 4660pb30002lb06 : 141 182 223 264 305 346 387 428 469 510 674 1084 1207 1289 1494 1535 1576 16171658 1699 3093pb20003lb03 : 57 64 65 66 67 68 69 70 71 72 73

FIGURE 6.9 – Numéro des cubes satisfiables des instances en possédant.

6.4 Conclusion

Nos résultats montrent que nos cubes sont assez diversifiés. Cela nous prouve que l’adaptation del’algorithme UCT afin de générer des cubes pour SAT est fonctionnelle. Nous observons aussi que lecalcul des valeurs UCB est mal réglé sur certaines instances. Une solution consisterait à calculer lesvaleurs UCB dynamiquement. Les tests sur la qualité des cubes nous montrent qu’il est envisageable defaire une telle division de l’arbre de recherche en SAT dans un cadre massivement parallèle. En effet, noustrouvons quelques cubes satisfiables dont certains d’une bonne qualité, sans avoir testé tous les cubesd’une instance mais seulement 200. De futures recherches permettront de tester différentes heuristiqueset de faire une simulation plus précise des cubes. Rappelons que cette génération de cubes n’est que lapremière brique de notre algorithme de colonie d’abeilles adapté à SAT. Nous pouvons considérer que lesolveur de type SCOUT est prêt à être utilisé dans notre algorithme mémétique.

59

Conclusion

Les travaux réalisés durant ce stage concernent la mise en place d’une approche massivement paral-lèle pour la résolution pratique du problème de satisfaisabilité de contraintes (SAT). Dans ce cadre, nousproposons un nouveau schéma de parallélisme basé sur un paradigme inspiré des colonies d’abeilles. Eneffet, dans la nature, nous retrouvons de nombreuses situations où des tâches sont réalisées efficacementen collaboration (colonies de fourmis, colonies d’abeilles, ...).

Après avoir introduit, dans les chapitres 1 à 3, les différents éléments nécessaires à la compréhensionde ce manuscrit. Nous avons présenté dans les chapitres 4 et 5, nos contributions puis, dans le chapitre 6,des résultats expérimentaux préliminaires.

La première contribution exposée dans ce rapport concerne une définition formelle d’une instancia-tion de l’algorithme mémétique des colonies d’abeilles au cadre de la résolution parallèle du problèmeSAT. Nous avons constaté que ce schéma s’adapte naturellement à la définition d’une approche collabo-rative. En effet, nous avons pu voir qu’il était possible de diviser la recherche d’une solution de manièreà assigner à chaque type d’abeilles un travail bien spécifique : des abeilles pour la gestion des clausesapprises (le nectar), des abeilles pour une exploration collaborative (les abeilles scouts) et des abeillespour la recherche concrète d’une solution (les abeilles butineuses).

Ce schéma algorithmique étant complexe, nous nous sommes dans un premier temps focalisés surla mise en place des abeilles scouts. Ce type d’abeilles a pour but d’explorer l’espace de recherche afinde trouver les parties intéressantes. Dans le cadre de SAT, cela consiste à la génération d’un arbre derecherche incomplet où les chemins de la racine à une feuille représentent une conjonction de littéraux(aussi appelée cube), permettant la considération d’un sous problème. Ici, nous avons principalementétudié la mise en place d’une abeille scout pour la résolution d’instances satisfiables, cette méthode estnommée SCOUT. Ainsi, le but du scout sera de générer des cubes conduisant à une solution. La générationd’un tel cube est aussi difficile que de résoudre le problème initial. De ce fait, nous avons choisi de nousappuyer sur une méthode nommée UCT permettant de traiter le dilemme exploitation/exploration. En ef-fet, dans l’optique de choisir les meilleurs cubes dans un arbre de recherche, nous avons été confrontés àce dilemme : faut-il exploiter un cube déjà considéré comme bon en lui rajoutant des littéraux ou retenternotre chance avec un nouveau cube. Les résultats exposées au chapitre 6 sur la méthode SCOUT nousmontre qu’une telle adaptation est envisageable dans le cadre de SAT.

Nos contributions ouvrent de nombreuses perspectives, notamment au niveau des heuristiques choi-sies. En effet, il est préférable de tester plusieurs heuristiques pour ainsi sélectionner la meilleure. Notreprogramme est capable d’adapter plusieurs solveurs pour les heuristiques. Une amélioration possible estde transformer notre méthode en utilisant la puissance de la parallélisation, afin d’affiner les simulationsfaites dans SCOUT. Pour l’instant, nous n’utilisons pas une véritable simulation. Par ailleurs, il se trouveque les méta-heuristiques des colonies d’abeilles n’utilisent pas tous les cœurs au début de la recherche,

60

ces cœurs pourraient donc servir à notre méthode SCOUT. Nous pouvons donc utiliser un solveur pourfaire la simulation. N’oublions pas aussi que les abeilles continueront à travailler sur l’arbre contenant lescubes créés par la méthode SCOUT via notre algorithme général sur les colonies d’abeilles butineuses. Lapartie UCB de notre algorithme peut être grandement améliorée, en effet, ces valeurs UCB sont difficilesà régler : un réglage statique ne suffit pas. La création des fils spéciaux possède aussi ce problème carelle est basée sur une valeur de type UCB.

Toutes ces améliorations s’inscrivent dans un avenir proche. En effet, une thèse sur ce même sujetpoursuivra la construction de notre méthode mémétique. Les problèmes alors rencontrés par les résultatsnous ont permis d’avancer dans cette construction.

61

Bibliographie

[ABK13] M. AIGNER, A. BIERE, et C.M. KIRSCH. « Analysis of Portfolio-Style Parallel SATSolving on Current Multi-Core Architectures ». Dans Submitted, 2013. (document)

[ACBF02] Peter AUER, Nicolò CESA-BIANCHI, et Paul FISCHER. « Finite-time Analysis of theMultiarmed Bandit Problem. ». Machine Learning, 47(2-3) :235–256, 2002. 3, 3.2, 3.2.2

[ACBFS03] Peter AUER, Nicolo CESA-BIANCHI, Yoav FREUND, et Robert E. SCHAPIRE. « TheNonstochastic Multiarmed Bandit Problem ». SIAM J. Comput., 32(1) :48–77, janvier2003. 3

[AHJ+12] Gilles AUDEMARD, Benoît HOESSEN, Saîd JABBOUR, Jean-Marie LAGNIEZ, et CédricPIETTE. « PeneLoPe, a Parallel Clause-Freezer Solver ». Dans Proceedings of SAT

Challenge 2012 : Solver and Benchmarks Descriptions, pages 43–44, Lens, may 2012.https ://helda.helsinki.fi/handle/10138/34218. 2.2.2, 2.2.3

[ALMS11] Gilles AUDEMARD, Jean-Marie LAGNIEZ, Bertrand MAZURE, et Lakhdar SAIS. « OnFreezing and Reactivating Learnt Clauses. ». Dans Karem A. SAKALLAH et LaurentSIMON, éditeurs, SAT, volume 6695 de Lecture Notes in Computer Science, pages 188–200. Springer, 2011. 2.2.3

[ALS13] Gilles AUDEMARD, Jean-Marie LAGNIEZ, et Laurent SIMON. « Improving Glucose forIncremental SAT Solving ith Assumptions : Application to MUS Extraction ». 2013. 6.1

[AO10] Peter AUER et Ronald ORTNER. « UCB revisited : Improved regret bounds for the sto-chastic multi-armed bandit problem. ». Periodica Mathematica Hungarica, 61(1-2) :55–65,2010. 3.2.2

[Bie08] Armin BIERE. « PicoSAT Essentials ». Journal on Satisfiability, Boolean Modeling and

Computation (JSAT), 4(2-4) :75–97, 2008. 2.2.2

[Bie10] Armin BIERE. « Lingeling, Plingeling, PicoSAT and PrecoSAT at SAT Race 2010 ».Rapport technique, 2010. 2.2.2

[BOT07] Adil BAYKASOGLU, Lale OZBAKIR, et Pinar TAPKAN. « Artificial Bee Colony Algorithmand Its Application to Generalized Assignment Problem ». Dans Swarm Intelligence, Focus

on Ant and Particle Swarm Optimization, FelixT.S.Chan and Manoj KumarTiwari (Ed.).InTech, DOI : 10.5772/5101, 2007. 4

[CM07] Pierre-Arnaud COQUELIN et Rémi MUNOS. « Bandit Algorithms for Tree Search ».CoRR, abs/cs/0703062, 2007. 3.3.3

[CM10] Antoine CORNUEJOLS et Laurent MICLET. Apprentissage artificiel : Concepts et algo-

rithmes. Eyrolles, juin 2010. 8, 3.3.3

[Coo71] Stephen A. COOK. « The Complexity of Theorem-proving Procedures ». Dans Proceedings

of the Third Annual ACM Symposium on Theory of Computing, STOC ’71, pages 151–158,New York, NY, USA, 1971. ACM. (document), 1.4

62

[CSH08] Geoffrey CHU, Peter J. STUCKEY, et Aaron HARWOOD. « PMiniSAT : A Parallelizationof MiniSAT 2.0 ». Rapport technique, 2008. 2.2.7

[CTL06] CMAP, TAO, et LRI. « Programme MoGo : http ://senseis.xmp.net/ ?MoGo », 2006.3.3.3

[DG97] Marco DORIGO et Luca Maria GAMBARDELLA. « Ant Colony System : A cooperativelearning approach to the traveling salesman problem ». IEEE TRANSACTIONS ON EVO-

LUTIONARY COMPUTATION, 1997. (document)

[Fly72] Michael J. FLYNN. « Some Computer Organizations and Their Effectiveness ». IEEE

Trans. Comput., 21(9) :948–960, septembre 1972. 2.1.2

[GW06] Sylvain GELLY et Yizao WANG. « Exploration exploitation in Go : UCT for Monte-CarloGo ». Dans NIPS : Neural Information Processing Systems Conference On-line trading of

Exploration and Exploitation Workshop, Canada, décembre 2006. 3.3.3

[Her03] Marc HERBSTRITT. « zChaff : Modifications and Extensions », 2003. 2.2.2

[HKWB12] M. HEULE, O. KULLMANN, S. WIERINGA, et A. BIERE. « Cube and Conquer : GuidingCDCL SAT Solvers by Lookaheads ». 7261 :50–65, 2012. Best paper award, reported2011 too, now formally published. (document), 2.2, 2.3

[HS09] Youssef HAMADI et Lakhdar SAIS. « ManySAT : a parallel SAT solver ». JOURNAL ON

SATISFIABILITY, BOOLEAN MODELING AND COMPUTATION (JSAT), 6, 2009. 2.2.2

[JLHS12] Saïd JABBOUR, Nadjib LAZAAR, Youssef HAMADI, et Michelle SEBAG. « Cooperationcontrol in Parallel SAT Solving : a Multi-armed Bandit Approach ». dec 2012. dans lecadre de NIPS’12. 3.2.2

[JLU01] Bernard JURKOWIAK, Chu Min LI, et Gil UTARD. « Parallelizing Satz Using DynamicWorkload Balancing ». Dans In Proceedings of Workshop on Theory and Applications of

Satisfiability Testing (SAT’2001, pages 205–211. Elsevier Science Publishers, 2001. 2.2.7

[Joh88] Eric E. JOHNSON. « Completing an MIMD Multiprocessor Taxonomy ». SIGARCH Com-

put. Archit. News, 16(3) :44–47, juin 1988. 2.1.2

[KA09] Dervis KARABOGA et Bahriye AKAY. « A survey : algorithms simulating bee swarmintelligence. ». Artif. Intell. Rev., 31(1-4) :61–85, 2009. 4

[KS06] Levente KOCSIS et Csaba SZEPESVÁRI. « Bandit Based Monte-carlo Planning ». pages282–293, 2006. 3.3, 8

[KSTW06a] Philip KILBY, John K. SLANEY, Sylvie THIÉBAUX, et Toby WALSH. « Estimating SearchTree Size. ». Dans AAAI, pages 1014–1019. AAAI Press, 2006. 4.1.3

[KSTW06b] Philip KILBY, John K. SLANEY, Sylvie THIÉBAUX, et Toby WALSH. « Estimating SearchTree Size. ». Dans AAAI, pages 1014–1019. AAAI Press, 2006. 5.2.6

[MdWH14] Sid MIJNDERS, Boris de WILDE, et Marijn HEULE. « Symbiosis of Search and Heuristicsfor Random 3-SAT ». CoRR, abs/1402.4455, 2014. 5.3

[PD07] Knot PIPATSRISAWAT et Adnan DARWICHE. « A Lightweight Component CachingScheme for Satisfiability Solvers ». Dans Proceedings of the 10th International Confe-

rence on Theory and Applications of Satisfiability Testing, SAT’07, pages 294–299, Berlin,Heidelberg, 2007. Springer-Verlag. 2.2.3

[Pey12] Rémi PEYRE. « Méthodes probabilistes pour la simulation ». 2012.

[PG09] Duc-Nghia PHAM et Charles GRETTON. « gNovelty+ (v. 2) ». Dans SAT 2009 Competitive

Events Booklet, 2009. 2.2.2

63

Bibliographie

[PTGS08] Duc Nghia PHAM, John THORNTON, Charles GRETTON, et Abdul SATTAR. « CombiningAdaptive and Dynamic Local Search for Satisfiability ». 4 :149–172, July 2008. 2.2.2

[Rob52] Herbert ROBBINS. « Some aspects of the sequential design of experiments ». Bull. Amer.

Math. Soc., 58(5) :527–535, 1952. 3.1.1

[Rou12] Olivier ROUSSEL. « ppfolio ». http ://www.cril.univ-artois.fr/˜roussel/ppfolio/, AccessedMay 2012. (document), 2.2.2

[SBK01] Carsten SINZ, Wolfgang BLOCHINGER, et Wolfgang KÜCHLIN. « PaSAT - parallel SAT-checking with lemma exchange : Implementation and applications ». Dans LICS 2001

Workshop on Theory and Applications of Satisfiability Testing (SAT 2001), volume 9 of

Electronic Notes in Discrete Mathematics. Elsevier Science Publishers, 2001. 2.2.7

[SE02] Niklas SÖRENSSON et Niklas EEN. « MiniSat v1.13 - A SAT solver with conflict-clauseminimization. 2005. SAT-2005 Poster. 1 Perhaps under a generous notion of “part-time”,but still concurrently taking a statistics course and leading a normal life ». Rapport tech-nique, 2002. 2.2.2, 6

[SE08] Niklas SÖRENSSON et Niklas EÉN. « MiniSat 2.1 and MiniSat++ 1.0 — SAT Race 2008Editions ». Rapport technique, 2008. 2.2.7

[Sen14] SENSEIS. « Jeu qui implémente UCT : http ://senseis.xmp.net/ ?UCT ». 2014. 3.3.3

[Sil12] Sievers SILVAN. « Implementation of the UCT Algorithm for Dopp elkopf ». 2012. 3.3.3

[SS96] João P. Marques SILVA et Karem A. SAKALLAH. « GRASP&Mdash ;a New Search Algo-rithm for Satisfiability ». Dans Proceedings of the 1996 IEEE/ACM International Confe-

rence on Computer-aided Design, ICCAD ’96, pages 220–227, Washington, DC, USA,1996. IEEE Computer Society. 2.2.2

[VS09] Pascal VANDER-SWALMEN. « Aspects parallèles des problèmes de satisfaisabilité », 2009.2.2.6

[ZB94] Hantao ZHANG et Maria Paola BONACINA. « Cumulating Search in a Distributed Com-puting Environment : A Case Study in Parallel Satisfiability ». pages 422–431, 1994. 2.2.5

[ZBP+96] Hantao ZHANG, Maria Paola BONACINA, Maria PAOLA, BONACINA, et Jieh HSIANG. «PSATO : a Distributed Propositional Prover and Its Application to Quasigroup Problems ».volume 21, pages 543–560, 1996. 2.2.7

64

Résumé

Le but de ce stage consiste tout d’abord à étudier les méthodes de parallélisation du problème SAT

et les algorithmes de types essaims d’abeilles ou colonies de fourmis. Une fois cette étude faite, nousproposons une nouvelle approche de parallélisation du problème SAT basé (bien évidemment) sur lesessaims d’abeilles. Chaque abeille sera associée à un démonstrateur SAT (de type CDCL, recherche locale,look ahead..) et à chaque étape un certain nombre d’informations seront échangées afin d’améliorerles insectes pour l’étape suivante. Nous proposons alors une méthodes représentant une abeille de typeSCOUT permettant de générer des cubes pour SAT. On peut noter que cette approche peut être génériqueet appliquée à d’autres paradigmes combinatoires comme les problèmes CSP, les pseudo booléens ...

Mots-clés: SAT parallèle, Algorithmes de Colonies d’abeilles

65

colonies d’abeilles et sat parall`eleszczepanski/res/colonies d... · en jeu autant de...

Documents