La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

Une (gentle?) introduction à ASP (Programmation par ensembles réponses) Jacques Nicolas INRIA /IRISA Rennes.

Présentations similaires


Présentation au sujet: "Une (gentle?) introduction à ASP (Programmation par ensembles réponses) Jacques Nicolas INRIA /IRISA Rennes."— Transcription de la présentation:

1 Une (gentle?) introduction à ASP (Programmation par ensembles réponses) Jacques Nicolas INRIA /IRISA Rennes

2 Answer Set Programming Approche déclarative : modélisation du problème à résoudre sous formes d’axiomes et de contraintes exprimées dans un langage logique; Les modèles logiques solutions de l’ensemble de formules, les ensembles réponses, sont les résultats du programme. Des solveurs associés effectuent la recherche d’une, de plusieurs, ou de l’ensemble des solutions.

3 Résolution en programmation classique Programme : Comment résoudre Programme : Comment résoudre Problème Solutions Compilation du programme (binaire) Compilation du programme (binaire) Sorties Spécification programmation Interprétation compilateurexécution

4 Résolution à base de modèles (et ASP) Représentation du problème (langage logique) Représentation du problème (langage logique) Problème Solutions Compilation du problème (formules booléennes) Compilation du problème (formules booléennes) Modèles (ensembles réponses) Modèles (ensembles réponses) Modélisation Interprétation InstancieurSolveur

5 Le langage Prolog, c’est différent d’ASP ? Prolog= Programmation en Logique, même domaine, approche « déclarative » (on décrit des relations, pas des procédures). Syntaxiquement, il y a des ressemblances évidentes Terme –Constante : entier, mot de {a-z, A-Z,0-9,_}* débutant par une minuscule. –Variable : mot de {a-z,A-Z,0-9,_}* débutant par une majuscule. –Fonction : constante(terme,… terme), opérateurs infixes (a+b) ou notations de liste - L=[a,b,c]=[a|U], U =[b,c], [c]=[c|[ ]]=‘.’(c,[]) - Clause –Fait : p(2,a). – Règle : q(X) :- p(X,Y), q(Y). – But : :- q(2). Si p(X,Y) est vrai et q(Y) est vrai, alors q(X) est vrai aussi. Est-ce que q(2) est vrai? p(2,a) est vrai.

6 Spécification du problème : définir member(X,L) qui est vérifié si X est un élément de la liste L  x,L 1, member(x,L 1 )   L 2,y L 1 =[y|L 2 ]  (x=y  member(x,L 2 )) En Prolog : member(X,[X|L]). member(X,[Y|L]):- member(X,L). Purement déclaratif ? Presque… Un premier programme Prolog member(a,[a]). member(b,[a,b,c]).

7 domino_chain(L):- domino_chain(L, []). domino_chain([X,Y|L], D):- domino(X,Y), admissible(X,Y,D), domino_chain(L,[[X,Y]|D]). domino_chain([], _D). admissible(X,Y,L):- not_member([X,Y], L). admissible(X,Y,L):- not_member([Y,X], L). not_member(P, L):- member(P,L),!, fail. not_member(P, L). La négation : négation par échec

8 Une approche plus déclarative: l’ordre des clauses n’a aucune importance. Le langage inclut l’opérateur de négation. On peut écrire des termes quelconques mais par contre, tout doit se ramener à du propositionnel. Les solutions sont des modèles de l’ensemble des clauses: des ensembles d’atomes vrais dans la théorie décrite. Le langage inclut l’expression de critères à optimiser. Le solveur propose différents modes de raisonnement. ASP vs Prolog

9 Définition de domaine par un fait : Définition de domaine par une règle : odomino(d(X,Y), croissant, left, X) :- domino(d(X,Y)). odomino(d(X,Y), croissant, right, Y) :- domino(d(X,Y)). odomino(d(X,Y),decroissant, left, Y) :- domino(d(X,Y)). odomino(d(X,Y),decroissant, right,X) :- domino(d(X,Y)). Paramètres : place(1.. chain_size).. Les dominos en ASP : définir les domaines dir(left). dir(right). dice(0..6). sens(croissant; decroissant). domino(d(X,Y)) :- dice(X), dice(Y), X<=Y. #const chain_size=28.

10 Installation : Une version binaire linux/windows/mac : Appel : (liste des options avec option –help) gringo domino1.lp -t Pour voir le modèle instancié généré gringo input.lp model.lp –c chain_size=28 | clasp –stats 1 solution clingo domino1.lp –n solutions gringo domino1.lp | clasp –n 0 Toutes les solutions Gringo Lua scripts Gringo solver Clasp Clasp solver Utiliser les programmes de Potassco clingo

11 Langage simple mais très expressif (très différent de la prog. linéaire, contient aussi la disjonction). Même base que Prolog (termes, clauses). Commentaires % ou %* *% Alternatives a;b 1..3 a,b;;c,d Littéral : p not q X

12 Il n’y a pas de notion de liste, on écrit directement les domaines comme vu précédemment. ville(brest;rennes;nantes;paris;lille). Plus grande ville de France : Plus petite ville de France : On dispose en fait de la donnée du nombre d’habitants des villes dans le fichier france.lp, prédicat ville(Nom, Population). Ecrire les mêmes prédicats sur le critère de la taille de la population. Un premier programme ASP : plus petit et plus grand élément d’un domaine plusgrandeville(V):- ville(V), U<=V:ville(U). pluspetiteville(V):- ville(V), not ville(U):ville(U):U

13 Choix d’une chaine de dominos complète: Un domino a 1 orientation et 1 place, chaque place 1 domino orienté A écrire : –Les doubles sont arbitrairement orientés dans le sens croissant; –On veut commencer la chaîne par un double zéro; –Les dominos doivent avoir les bords qui se touchent égaux. domino1.lp : chaînage complet correct 1{ domino_chain(D,K,S) : place(K):sens(S)}1 :- domino(D). :- 2{domino_chain(D,K,S) : domino(D):sens(S)}, place(K). 1{ domino_chain(D,K,S) : place(K):sens(S)}1 :- domino(D). :- 2{domino_chain(D,K,S) : domino(D):sens(S)}, place(K).

14 %Les doubles sont arbitrairement orientés dans le sens croissant %On veut commencer la chaîne par un double zéro % Les dominos doivent avoir les bords qui se touchent égaux Une solution pour le chaînage de dominos :- domino_chain ( d(X,X), K, decroissant ). :- not domino_chain(d(0,0),1,croissant). :- domino_chain(D1,K,O1), domino_chain(D2,K+1,O2), odomino(D1,O1,right,X), not odomino(D2,O2,left,X). :- domino_chain(D1,K,O1), domino_chain(D2,K+1,O2), odomino(D1,O1,right,X), not odomino(D2,O2,left,X).

15 Un puzzle sur les dominos… D11D12D13 D17D14 D16D15 Placer correctement tous les dominos en 4 super-dominos (rectangles); Les dominos s’apparient en chaine ainsi que les coins des super-dominos; Total décroissant des points des super-dominos de gauche à droite. Optimisation :Total maximal pour le 1 er puis le 4ème superdomino ? Quelles sont toutes les solutions optimales possibles ? Y-a-t-il un pattern commun a l’ensemble des solutions ? Optimisation :Total maximal pour le 1 er puis le 4ème superdomino ? Quelles sont toutes les solutions optimales possibles ? Y-a-t-il un pattern commun a l’ensemble des solutions ? D21D22D23 D27D24 D26D25 D31D32D33 D37D34 D36D35 D41D42D43 D47D44 D46D45 On ne considèrera que les solutions à une symétrie horizontale près

16 Chaque place de domino à l’intérieur du super-domino est numérotée (de 1 à 7) dans l’ordre des aiguilles d’une montre; Hint : On n’a besoin de préciser que la valeur à gauche d’un domino, l’autre s’en déduit automatiquement par chaînage… Ecrire d’abord le programme générant comme ensembles réponses tous les super-dominos possibles (vérifier que les dominos diffèrent tous dans un deuxième temps)… …puis étendre pour choisir 4 super-dominos, chacun étant numéroté (de 1 à 4). Modélisation des super-dominos

17 Générer tous les super-dominos possibles #const nb_places=7. sdomino_place(1..nb_places). dice(0..6). 1{ldom_place(K,D):dice(D)}1:- sdomino_place(K). #const nb_places=7. sdomino_place(1..nb_places). dice(0..6). 1{ldom_place(K,D):dice(D)}1:- sdomino_place(K). 1.Générer l’espace des possibles sans se soucier des dominos utilisés plusieurs fois 2.Eliminer les configurations avec des dominos égaux domino(K1,DA,DB):- ldom_place(K1,DA), next_place(K1,K2), ldom_place(K2,DB), DA<=DB. domino(K1,DB,DA):- ldom_place(K1,DA), next_place(K1,K2), ldom_place(K2,DB), DB

18 %Constants #const nb_sdominos=4. #const nb_places=7. dice(0..6). %The superdomino frames and the 2 associated chaining relations. sdomino_number(1..nb_sdominos). sdomino_place(1..nb_places). next_sdomino(1,2;;2,3;;3,4). next_place(K,K1):- sdomino_place(K), K1=(K #mod nb_places)+1. %Choose the left part of dominos in the superdomino 1{ldom_place(I,K,D):dice(D)}1:- sdomino_number(I), sdomino_place(K). % Horizontal symetry breaking : domino(1,2) < domino(7,6) :- ldom_place(1,1,T1), ldom_place(1,7,T7), T7

19 %Infer dominos from ldom_place and check they are all different domino(I,K1,DA,DB):- ldom_place(I,K1,DA), next_place(K1,K2), ldom_place(I,K2,DB), DA<=DB. domino(I,K1,DB,DA):- ldom_place(I,K1,DA), next_place(K1,K2), ldom_place(I,K2,DB), DB

20 %The sum of all dices must be maximal %Alternative if using cautious mode %:- [ldom_place(1,K,T)=T]32. %:- [ldom_place(4,K,T)=T]15. #hide. #show total/2. domino2.lp : optimisation

21 Meilleurs totaux 1 et 4 : 33 et 16 (utilisation heuristique Vsids). 22 solutions avec 33 et 16 (options --opt-all --opt-value=114,131). Intersection des solutions ldom_place(1,4,3) total(4,16) total(3,17) total(2,18) total(1,33) Réponses pour le puzzle des dominos

22 Les possibilités du langage sont en fait plus complexes mais au-delà des possibilités d’un cours d’introduction. On peut écrire des programmes disjonctifs, ce qui signifie qu’il peut y avoir une alternative au niveau de la tête des clauses (e.g. p|q. ou p|q:-r.). Il faut alors faire appel à un solveur spécifique (claspD) et la complexité explose… Notons qu’il est possible d’utiliser la négation classique en utilisant le moins (e.g –p:-q.) Remarque sur l’expressivité dans gringo

23 Techniquement, ASP offre un cadre unifié où sont intégrés des aspects bases de données, bases de connaissances, résolution de contraintes et programmation logique. Il est possible de faire de l’optimisation et d’utiliser différents modes de raisonnement pour chercher une solution, toutes, les meilleures, leur intersection ou leur union. La résolution des problèmes combinatoires est le cœur de cible d’ASP. En particulier c’est un candidat de choix pour attaquer des problèmes NP-complets et NP-difficiles (graphes, raisonnement,…) du fait de la facilité de mettre au point et tester différents modèles et différentes heuristiques. ASP, c’est utile dans quels cas ?

24 remplacer des algorithmes classiques maîtrisés : pour faire du tri, du calcul ou du traitement de séquences, il faut revenir à un langage de programmation classique. Le langage de script Lua est inclus dans gringo pour les pré et post-traitements; travailler dans des espaces peu structurés et peu contraints ou des espaces difficiles à discrétiser. résoudre un problème qui nécessiterait de nombreuses étapes successives qui communiquent : un programme ASP ne permet pas d’écrire des procédures. ASP ne doit pas être utilisé pour…

25 Un programme positif est constitué d’un ensemble de règles (clauses définies) A:-B 1,B 2,…B m ou A (la tête de la règle) et les B (le corps) sont des atomes (variables booléennes). A:-B 1,B 2,…B m correspond à la formule  B 1   B 2  …  B m  A Un ensemble d’atomes X est clos pour un programme positif si pour l’ensemble de ses règles r, corps(r)  X  tête(r)  X (C’est un modèle du programme vu comme une formule). L’ensemble réponse (answer set) d’un programme positif P est le plus petit ensemble d’atomes qui soit clos pour P. Il existe et est unique. Et la sémantique ? Programmes positifs

26 Un programme est constitué de manière plus générale d’un ensemble de règles A:-B 1,B 2,…B m, not B m+1, not B m+2,… not B m+n Le réduit d’un programme par rapport à un ensemble d’atomes X est l’ensemble des règles A:-B 1,B 2,…B m telles qu’aucun des B m+1, B m+2,… B m+n n’appartient à X. Un ensemble réponse (on dit aussi modèle stable) d’un programme P est un plus petit ensemble d’atomes clos pour le réduit de P (il peut y en avoir 0, 1 ou plusieurs). Autrement dit, on ne met dans un modèle l’atome d’une tête de règle que si la règle est un fait (règle réduite à une tête) après en avoir enlevé les littéraux négatifs qui ne sont pas dans le modèle ou si tous les littéraux positifs du corps sont dans le modèle et aucun des littéraux négatifs. Et la sémantique ? Programmes avec not

27 p:- p. q:- not p. interprétations possibles : {p,q}, {p}, {q},  (stable si en réduisant le programme avec et par clôture, on retombe sur le même ensemble…) p:- not q. q:- not p. interprétations possibles : {p,q}, {p}, {q},  Autre écriture 1{p,q}1. p:- not p. interprétations possibles : {p},  Où l’on teste si la sémantique de base est comprise…

28 p:- p. q:- not p. {p,q} : dans ce cas, le programme réduit est p:- p. dont l’ensemble clos minimal associé est , pas de stabilité {p} : dans ce cas, le programme réduit est p:- p. dont l’ensemble clos minimal associé est , pas de stabilité {q} : dans ce cas, le programme réduit est p:- p. q. dont l’ensemble clos minimal associé est {q}. OK  : dans ce cas, le programme réduit est p:- p. q. dont l’ensemble clos minimal associé est {q}, pas de stabilité p:- not q. q:- not p. ensembles réponses : {p}, {q} p:- not p. pas d’ensemble réponse Sémantique : solutions… Un ensemble réponse contient des atomes du programme. Tout élément d’un ensemble réponse est supporté par une règle

29 C’est le rôle de l’instancieur (grounder), qui agit comme une base de données déductive, de les traiter. Etant donné un programme P, on peut distinguer –L’ensemble des termes sans variables H (univers de Herbrand); –Pour une règle r l’ensemble des variables de r var(r). On définit le programme instancié ground(P) en remplaçant toutes les règles r par des règles instanciées ground(r) où les variables sont remplacées par des termes de H: ground(r) = { r  |  : var(r)  H} gringo est un instancieur intelligent réduisant au mieux le nombre d’instances produites. C’est en fait un véritable solveur qui s’occupe des aspects purement déterministes du calcul. Au total, un ensemble réponse est un ensemble minimal sur le réduit du programme instancié Et les variables ?

30 p(X,Y) :- q(X,Y). q(a,b). q(b,c). {a, b, c} { p(a,a):-q(a,a), p(a,b):-q(a,b), p(a,c):-q(a,c), p(b,a):-q(b,a), p(b,b):-q(b,b), p(b,c):-q(b,c), p(c,a):-q(c,a), p(c,b):-q(c,b), p(c,c):-q(c,c), q(a,b), q(b,c) } { p(a,b), p(b,c), q(a,b), q(b,c) } Exemple de grounding…

31 {A 1,A 2,…A m } :- B m+1,B m+2,…B n, not B n+1, not B n+2,… not B p Intuitivement : tout sous ensemble de {A 1,A 2,…A m } peut être inclus dans l’ensemble réponse lors de la clôture. Règle équivalente au programme suivant : B:- B m+1,B m+2,…B n, not B n+1, not B n+2,… not B p. A 1 :- B, not C 1. C 1 :- B, not A 1. A 2 :- B, not C 2. C 2 :- B, not A 2. … A m :- B, not C m. C m :- B, not A m. Ensembles réponses de : p. {q}:-p. ? Extension à d’autres constructeurs…

32 :- B m+1,B m+2,…B n, not B n+1, not B n+2,… not B p. équivaut à new :- B m+1,B m+2,…B n, not B n+1, not B n+2,… not B p, not new. p :- k{A 1,A 2,…A m }l équivaut à p :- q, not r. q :- cc(A 1, k). r :- cc(A 1, l+1). cc(A 1,I+1):- cc(A 2,I), A 1. cc(A 1,I):- cc(A 2,I), A 1. Et pour les contraintes d’intégrité et les contraintes de cardinalité?

33 En logique classique, si on fait croître une théorie, on ne peut qu’en déduire plus de faits : {p, p  q, (q  r)  s} permet de conclure {p, p  q, (q  r)  s, q } Ajouter r à la théorie permet de conclure {p, p  q, (q  r)  s, q, r } La réalité de la science exprime des besoins un peu différents : lorsqu’on dispose de plus de faits, une théorie peut être remise en question partiellement pour aboutir à un ensemble de conclusions réduite… ASP utilise une logique non monotone: {p, p  q, (q  r)  s} permet de conclure {p, p  q, (q  r)  s, q, s } Ajouter r à la théorie permet de conclure {p, p  q, (q  r)  s, q, r } Toutes les logiques se valent-elles ?

34 1.Prétraitement des données par un script Lua pour produire les faits de l’instance du problème traité; 2.Définition des domaines des variables; 3.Génération des choix d’ensembles réponse possible pour la classe de problèmes; 4.Test et filtrage des ensembles admissibles par contraintes d’intégrité; Réduction des solutions symétriques; 5.Optimisation hiérarchisée selon différents critères. Méthodologie de programmation de base

35 On peut sans problème générer un programme instancié avec quelques millions de variables. Cependant, cette limite est facilement atteinte par produits cartésiens : il faut limiter au maximum le nombre de variables différentes dans une clause. Il y a un compromis à équilibrer entre les parties résolues par gringo et par clasp. –Gringo dépense de la mémoire, il précalcule (tabule) tout ce qui peut être instancié à l’avance de manière déterministe. –Clasp dépense du CPU, il effectue les choix et élague dynamiquement l’espace de recherche Le solveur va être d’autant plus efficace qu’il pourra apprendre des nouvelles contraintes en cours de résolution : avoir un programme croisant des contraintes génériques mais redondantes peut être intéressant. L’art de la modélisation : Warning !

36 On n’échappe pas à la complexité, on peut juste tirer parti des particularités d’une instance de problème à résoudre : paramétrer l’espace de recherche de façon à faire dépendre la complexité d’un paramètre qui garde des valeurs raisonnable (penser à iclingo). ASP permet d’exprimer facilement des propriétés mathématiques sur un espace de recherche : plus vous aurez de propriétés, mieux ça marchera ! Il reste actuellement difficile de tracer un programme ASP pour savoir où se cache la partie complexe. Le découpage très modulaire en clauses indépendantes facilite cependant la mise aux points : procéder par étapes ! Il existe un prototype de profileur de l’exécution d’un programme mais qui n’est pas encore public. De la complexité…

37 Etant donné un graphe pondéré non orienté décrit par des faits trouver un circuit hamiltonien minimum sur ce graphe, c’est-à-dire un chemin en boucle qui passe une et une seule fois par tous les nœuds et minimise la somme des poids des arcs qu’il emprunte. Application à un circuit sur une carte routière de la France : france.lp. Exemple de la recherche de circuit hamiltonien minimum edge(Sommet1, Sommet2, Poids).

38 edge(X,Y,C):- edge(Y,X,C). edge(X,Y):- edge(X,Y,_). node(X;Y):- edge(X,Y). min_node(X):- node(X), not node(Y): node(Y):Y

39 On utilise des techniques issues de la résolution de contraintes et de la résolution SAT. La plupart des solveurs SAT utilisent des variantes de l'algorithme de Davis–Putnam–Logemann–Loveland (DPLL) DPLL consiste à appliquer la propagation unitaire sur les clauses, à éliminer les clauses pures et à choisir récursivement et avec backtrack la valeur de vérité d’une proposition. Un littéral est pur s’il apparaît toujours avec le même signe. Les clauses pures sont celles contenant des littéraux purs. L’inférence en ASP est un algorithme plus évolué qui consiste principalement à faire de la propagation unitaire sur des « nogoods » appris en cours de résolution de conflits et à faire du backjumping à la place du backtrack classique Un coup d’œil sur la façon dont ça marche

40 affectation=vrai; Tant que affectation –Propagation des conséquences déterministe du jeu de clauses; –Si pas de conflit (clause vide détectée) Alors si toutes les variables sont assignées – alors Sortir la solution; affectation=faux – sinon Choisir une variable et lui affecter une valeur de vérité Sinon si le conflit implique les 2 alternatives possibles du 1 er choix – alors Pas de solution; affectation=faux – sinon Backtrack : Défaire toutes les affectations faites depuis le dernier choix et essayer l’autre valeur de vérité pour ce choix La boucle de résolution avec DPLL

41 affectation=vrai; Tant que affectation –Propagation des conséquences déterministe du jeu de clauses; –Si pas de conflit (clause vide détectée) Alors si toutes les variables sont assignées – alors Sortir la solution; affectation=faux – sinon Choisir une variable et lui affecter une valeur de vérité Sinon si le conflit implique les 2 alternatives possibles du 1 er choix – alors Pas de solution; affectation=faux – sinon La boucle de résolution clasp dirigée par les conflits (CDCL) Analyser la source du conflit et ajouter une contrainte de conflit Défaire toutes les affectations de variable jusqu’à contrainte unitaire Analyser la source du conflit et ajouter une contrainte de conflit Défaire toutes les affectations de variable jusqu’à contrainte unitaire

42 Plusieurs solveurs existent en fait, il faut essayer... –Utilisation « tout en un » : clingo (gringo+clasp) –Solveur incrémental : iclingo (#base+ paramètre incrémentant d’un pas de résolution à l’autre #cumulative k +) –Solveur de contraintes sur entiers : clingcon Il existe un petit manuel ainsi que pas mal de slides de cours plus avancés sur le site potassco Il existe également en support une mailing-list, un forum de discussion et un wiki et même un groupe google+ ! https://plus.google.com/ / La suite potassco : utiliser ASP en pratique

43 Merci à Torsten Schaub et Martin Gebser dont je me suis beaucoup inspiré pour cette présentation. Answer Set Solving in Practice Martin Gebser, Roland Kaminski, Benjamin Kaufmann, and Torsten Schaub Synthesis Lectures on Artificial Intelligence and Machine Learning, Dec. 2012, Vol. 6, No. 3, Pages (doi: /S00457ED1V01Y201211AIM019)

44 –Langage : logique du premier ordre, clauses de Horn –Une seule structure de données : le terme –Algorithme = Logique + Contrôle [Kowalski] –Réécriture des requêtes par résolution SLD avec les clauses, en effectuant les points de choix dans un ordre fixé « haut-bas gauche-droite ». –Solution = instanciation des variables de la requête. –Enumération des solutions par retour arrière (backtracking) sur les points de choix. Paradigme de la programmation logique

45 Connaissance nécessaire du solveur en Prolog : exemple des dominos domino(X,Y):- member(X,[0,1,2,3,4,5,6]), member(Y,[0,1,2,3,4,5,6]). :- domino(A,B). Yes. A=1, B=1; … domino_chain ([X,Y]) :- domino(X,Y). domino_chain ([X,Y|L]):- domino(X,Y), domino_chain([Y|L]). versus domino_chain([X,Y|L]):- domino_chain([Y|L]), domino(X,Y). domino_chain([X,Y]):- domino(X,Y). Enumération de l’ensemble des solutions ou boucle infinie de résolutions sans solution !

46 La propagation unitaire est un mécanisme de simplification de clauses utilisant les clauses réduites à 1 seul littéral. Etant donné un ensembles de clauses comprenant une clause unitaire réduite au littéral p, on peut enlever de l’ensemble toutes les autres clauses qui contiennent p et enlever le littéral opposé ~p des clauses restantes. {p, p  q, not p  r, not r  s} se réduit ainsi à {p, r, not r  s} qui se réduit lui-même en {p, r, s}. Un nogood est un assignement de valeurs de vérité à un ensemble d’atomes qui suffit à provoquer la violation d’une contrainte du programme. Propagation unitaire sur nogood


Télécharger ppt "Une (gentle?) introduction à ASP (Programmation par ensembles réponses) Jacques Nicolas INRIA /IRISA Rennes."

Présentations similaires


Annonces Google