Introduction à l`Answer Set Programming

ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Introduction à l'Answer
Interfaçage Python/clingo
Conclusion
References
Set Programming
Thomas Guyet Agrocampus-Ouest/IRISA-Inria
Séminaire du LIFO 9 mars 2015
T. Guyet Tuto ASP
1 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Outline
1
ASP
2
Syntaxe ASP par la pratique
3
Clustering avec ASP
4
Interfaçage Python/clingo
5
Conclusion
T. Guyet Tuto ASP
2 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Answer Set Programming I
Programmation ASP
idéal de la programmation déclarative : le problème est le
programme
⇒ modélisation du problème à résoudre sous formes d'axiomes et de
contraintes exprimées dans un langage logique ;
les résultats du programme sont des modèles logiques solution de
l'ensemble de formules
⇒ un modèle = un ensemble réponse
⇒ formalisé par des modèles de Herbrand
le résultat est un ensemble de modèles (ensembles réponses)
des solveurs associés eectuent la recherche d'une, de plusieurs, ou
de l'ensemble des solutions
T. Guyet Tuto ASP
3 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Answer Set Programming II
Résolution par la programmation classique
Problem
Solution
6
Specication
algorithmique
Interpreting
?
Programme
Comment résoudre
-Compilation
- Execution
-
Sortie
Solving
T. Guyet Tuto ASP
4 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Answer Set Programming III
Résolution par la programmation ASP
Problem
Solution
6
Modeling
Interpreting
?
Logic
Program
- Grounder
-
Solver
-
Stable
Models
Solving
T. Guyet Tuto ASP
5 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Programmation ASP et Prolog I
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
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)
Les clauses du programme sont également très ressemblantes
Fait : p (2, a) .
Règles : q(X) :− p(X,Y), q(Y).
Contraintes (ou buts) : :− q(2).
T. Guyet Tuto ASP
6 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Programmation ASP et Prolog II
Model Generation based approach (eg.
SATisability testing)
Theorem Proving based approach
(eg. Prolog)
1
Provide a representation of the
problem
A solution is given by a
derivation of a query









on(a , b) .
on(b,c) .
above(X,Y) :− above(X,Z), on(Z,Y).
above(X,Y) :− on(X,Y).
2
1
Provide a representation of
the problem
above(a,c).
Fatal Error : local stack overow .
?−
T. Guyet Tuto ASP
on(a, b) ∧ on(b, c )∧
(on(X , Y ) → above (X , Y ))∧
(on(X , Z ) ∧ above (Z , Y ) → above (X , Y ))
2
A solution is given by a model of the
representation (Herbrand model)
on(a, b),
on(b, c ),
on(a, c ),
on(b, b),
above (a, b), above (b, c ),
above (a, c ), above (b, b),
above (c , b)









7 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Programmation ASP et Prolog III
Diérences Prolog/ASP
Une approche plus déclarative : l'ordre des clauses n'a aucune
importance.
Un modélisation basée sur la négation par défaut (not)
⇒ not p ⇔ Si p ne peut être prouvé, alors on peut déduire p.
⇒ le programme q ← not p . engendre q (car p ne peut pas être falsié)
On peut écrire des termes du premier ordre 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.
T. Guyet Tuto ASP
8 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Conception d'un programme ASP
Principe "général" de programmation [Lif08]
1
ensemble de règles pour "générer" des modèles (modèles
potentielles)
2
ensemble de règles de dénition : règles classiques de prolog.
3
ensemble de contraintes : éliminent les modèles non-souhaités
4
directive d'achage : #show
B ces règles dénissent un espace de recherche qui sera parcourus
Coloration de graphe
1 node(1). node(2). node(3). node(4). node(5). node(6).
2 edge(1,2) . edge(1,3) . edge(1,4) . edge(2,4) . edge(2,5) .
3 edge(3,1) . edge(3,4) . edge(3,5) . edge(4,1) . edge(4,2) .
4 edge(5,4) . edge(5,6) . edge(6,2) . edge(6,3) . edge(6,5) .
5 col ( r ) . col ( m). col ( b) . col ( c ) . col ( g) . col ( o) .
6
7 1 { color ( X,C) : col ( C) } 1 :− node(X).
8 :− edge(X,Y), color ( X,C), color ( Y,C).
9
10 #show color/2.
T. Guyet Tuto ASP
edge(2,6) .
edge(5,3) .
9 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Principes de résolution
Résolution par la programmation ASP
Problem
Solution
6
Modeling
Interpreting
?
Logic
Program
- Grounder
-
Solver
-
Stable
Models
Solving
T. Guyet Tuto ASP
10 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Principes de résolution Interfaçage Python/clingo
grounding
Conclusion
References
I
Programme P
p (X , Y ) ← q (X , Y ). q (a, b). q (b, c ).
Univers de Herbrand H = {a, b , c }
Programme instancié

p (a, a) ← q (a, a),



p (b, a) ← q (b, a),
p (c , a) ← q (c , a),



q (a, b)
p (a, b) ← q (a, b), p (a, c ) ← q (a, c ),
p (b, b) ← q (b, b), p (b, c ) ← q (b, c ),
p (c , b) ← q (c , b), p (c , c ) ← q (c , c ),
q (b, c )







Instanciation par gringo
{p (a, b ), p (b , c ), q (a, b ), q (b , c )}
T. Guyet Tuto ASP
11 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Principes de résolution Interfaçage Python/clingo
grounding
Conclusion
References
II
Toutes les variables d'une règle doivent être "instanciables", sinon la
variable est dite unsafe.
:−
1 {
node(X), not color (X,C). % C is unsafe
color (X,C) } 1 :− node(X). % C is unsafe !
La manière la plus simple pour assurer cette contrainte est de dénir
un domaine ni pour chaque variable d'une règle.
:−
1 {
node(X), col (C), not color (X,C).
color (X,C) : col (C) } 1 :− node(X).
gringo essaye d'inférer le domaine pour réduire le nombre de règles
dans le programme instancié
Avertissement
Une instanciation mal pensée peut conduire à un besoin en mémoire très
important !
T. Guyet Tuto ASP
12 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Principes de résolution Interfaçage Python/clingo
Conclusion
References
solve
Stratégie générale clasp
Aectation=vrai
TANT QUE Aectation
Propagation des conséquences déterministe du jeu de clauses
SI pas de conit (clause vide détectée)
SI toutes les variables sont assignées
Sortir la solution
aectation=faux
SINON
Choisir une variable et lui aecter une valeur de vérité
SINON
Analyser la source du conit
ajouter une contrainte de conit
Défaire toutes les aectations de variable jusqu'à contrainte unitaire
T. Guyet Tuto ASP
13 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Principes de résolution vue pratique
Avertissement
Slides intuitifs servant à aider à la conception des programmes. Voir les
détails des solveurs pour les stratégies de résolution.
T. Guyet Tuto ASP
14 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Principes de résolution vue pratique
Attention à l'explosion combinatoire de l'espace de recherche !
Gestion de le redondance :
B
les modèles explorés ne peuvent pas partager d'information entre
eux !
B parallélisation possible du solveur
Trouver le nombre minimal de
couleurs pour colorer un graphe.
nb_colors (1..6) } 1.
K{ col(a ; m;b;c ; g ; o) } K :− nb_colors(K).
1{
1 {
:−
color (X,C) : col (C) } 1 :− node(X).
edge(X,Y), color (X,C), color (Y,C).
minimize{ K : nb_colors(K) }.
#
show color/2.
#
T. Guyet Tuto ASP
15 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Résolution avec la suite Potassco
clingo
gringo : instantiateur
clasp : solveur de contraintes (conict driven solver )
Appels de clingo
clingo text coloration.lp : pour voir le modèle instancié
⇒ très utile pour vérier que le programme correspond à notre idée de
la modélisation !
clingo coloration.lp : résolution (génère 1 ensemble réponse)
clingo -n 10 coloration.lp : résolution (génère 10 ensembles
réponses)
clingo -n 0 coloration.lp : résolution (génère toutes les
ensembles réponses)
clingo -n 0 stats quiet=2,2 coloration.lp :
statistiques de l'exécution, sans achage
clingo help : aide
T. Guyet Tuto ASP
16 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Outline
1
ASP
2
Syntaxe ASP par la pratique
3
Clustering avec ASP
4
Interfaçage Python/clingo
5
Conclusion
T. Guyet Tuto ASP
17 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Un peu de syntaxe (Gringo 4) I
Commentaires : % ou %∗ ... ∗%
Littéraux : p, not p, X<Y, U=V, U !=V, p(|20+T∗−3|/U)
⇒ toutes les variables/constantes sont interprétées comme des entiers
(pas d'opérations sur des nombres réels)
"extension conditionnelle" : r (X):q(X), désigne l'ensemble des r (X)
q (45;56;67) .
r (78) .
r (X):q(X). %%grounding: r(45);r(56);r(67).
B Lors de l'utilisation d'expressions conditionnelles, il faut faire
attention aux distinction , et ; .
q (45;56;67) .
r (56) .
u(X): q(X), not r (X). %deux modeles : r(56). q(45). q(56). q(67). u(45);u(67).
v(X): q(X); not r (X). %X unsafe
T. Guyet Tuto ASP
18 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Un peu de syntaxe (Gringo 4) II
Littéraux de choix ensemblistes : 1 { ... } 2 : choix d'un
sous-ensemble des atomes contenant 1 à 2 atomes
: 6 modèles possibles (tous sont des AS)
Déclaration des faits (pooling )
node(1).node(2).node(3). peut être simplié en node (1..3) .
edge(1,2) . edge(1,4) . edge(1,6) . peut être "simplié" en node (1,(2;4;6) ) .
1{
r (X):q(X) }
2.
3 formes de règles
Classique : autre (X) :− r (X), not q(X).
Règles de choix :
c (1.. n) .
1 { color ( X, I )
:
c( I )}
1 :−
v(X).
Contraintes (règles sans têtes) : :− r (X), q(x) .
Directives d'achage des prédicats : #show node/1., #show edge/2.
par défaut, tous les prédicats sont achés
si une directive #show est utilisée, les autres prédicats sont par défaut
cachés.
T. Guyet Tuto ASP
19 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Un peu de sémantique
Un programme est ensemble de règles de la forme :
A0 ← A1 , . . . , Am , not Am+1 , . . . , not An
où Ai désigne un atome propositionnel.
La sémantique intuitive de cette règle est :
si on a généré A1 , . . . , Am dans un modèle, et
qu'il est impossible de générer chacun des Am+1 , . . . , An ,
alors on peut générer A0
T. Guyet Tuto ASP
20 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Problème de recherche d'un cycle Hamiltonian
Une chaîne hamiltonienne est une chaîne qui passe une fois et une
seule par chaque sommet du graphe
Un cycle hamiltonien est une chaîne hamiltonienne qui est cyclique
Ressources
france.lp : chier de description de l'instance du problème
(données)
hamilton_v?.lp : diérentes versions de résolution
hamilton_optim.lp : partie de programme pour l'optimisation du
chemin de Hamilton (minimisation de la distance)
T. Guyet Tuto ASP
21 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Cycle Hamiltonien (version 1)
ville (angers,147571).
ville (bordeaux,239157).
ville ( brest ,141303).
ville (nantes,284970).
%Distances routieres
edge(angers,bordeaux, 335).
edge(angers, brest ,371) .
edge(angers,nantes ,90) .
edge(bordeaux,brest , 634).
edge(bordeaux,nantes,329).
edge( brest , nantes ,
305).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
edge(X,Y):− edge(X,Y,_). %projection des donnees
edge(X,Y,C):− edge(Y,X,C). %symetrisation des arcs
node(X;Y):− edge(X,Y). %generation des noeuds
start ( brest ) . % denition d'un point de depart
% denition d'une chaine
cycle (X,Y) } 1 :− edge(X,Y).
cycle (X,Y), { cycle (Y,Z) : node(Z)}0.
:− cycle ( X,Y), { cycle ( Z,X) : node(Z)}0.
0{
:−
%liste des points atteints
reached(Y):− cycle(X,Y), reached(X).
reached(Y):− cycle(X,Y), start (X).
%tous les noeuds doivent etre atteints
:−
node(X), not reached(X).
%on ne passe qu'une seule fois dans chaque noeud
:− 2{
#
cycle (X,Y) }, node(X).
show cycle/2.
Vérication
clingo 10 france.lp hamilton_v1.lp
clingo 0 quiet=2,2 stats france.lp hamilton_v1.lp
Statistiques
T. Guyet Tuto ASP
22 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Cycle Hamiltonien (version 1) : analyse du programme
Génération des cycles
cycle (X,Y) } 1 :− edge(X,Y). : instanciation très coûteuse (proportionnelle
au nombre d'arcs du graphe)
0{
requière beaucoup de mémoire lors de l'instanciation
le temps nécessaire à cette étape est important
risque d'avoir des résolutions diciles également (beaucoup de
modèles sont à évaluer)
⇒ Conclusions : il faut générer moins de modèles ! !
Idéal de la programmation déclarative ... certes, mais les programmes ecaces
nécessitent un peu de pratique !
T. Guyet Tuto ASP
23 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Cycle Hamiltonien (version 2)
Amélioration du programme
Astuce : si on ne passe qu'une fois pas ville, il y a exactement 1 cycle
partant et 1 cycle arrivant pour chaque noeuds
1 edge(X,Y):− edge(X,Y,_).
2 edge(X,Y,C):− edge(Y,X,C).
3 node(X;Y):− edge(X,Y).
4 start ( brest ) . % denition d'un point de
5
6 1{ cycle ( X,Y):edge(X,Y) }1 :− node(X).
7 1{ cycle ( X,Y):edge(X,Y) }1 :− node(Y).
8
9 reached(Y):− cycle(X,Y), reached(X).
10 reached(Y):− cycle(X,Y), start ( X).
11 :− node(X), not reached(X).
12 #show cycle/2.
depart
Statistiques
T. Guyet Tuto ASP
24 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Cycle Hamiltonien (version 3)
Elimination des solutions redondantes
Les symmétries de problèmes sont la plaie de l'ASP
redondance articielle de solutions dans des AS diérents
autant de travail à faire pour tous les cas dupliqués
Casser les symétries ore souvent des gains de temps de résolution !
⇒ les solutions sont dupliquées par deux sens possibles de parcours d'un
cycle (orienté)
1 edge(X,Y):− edge(X,Y,_). edge(X,Y,C):− edge(Y,X,C).
2 start ( brest ) . % denition d'un point de depart
3
4 1{ cycle ( X,Y):edge(X,Y) }1 :− node(X).
5 1{ cycle ( X,Y):edge(X,Y) }1 :− node(Y).
6 reached(Y):− cycle(X,Y), reached(X).
7 reached(Y):− cycle(X,Y), start ( X).
8 :− node(X), not reached(X).
9
10 :− cycle ( X,Y), cycle ( Z,X), start ( X), Z<Y.
11 #show cycle/2.
Statistiques
T. Guyet Tuto ASP
node(X;Y):− edge(X,Y).
Alternative ecace
25 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Exercice
From Richard Bird and Sharon Curtis : "Functional pearls : Finding
celebrities : A lesson in functional programming" J. Funct.
Program., 16(1) :1320, 2006.
Given the graph for a list of people at a party of people they know,
nd the celebrities at the party. A celebrity is a person that
everybody at the party knows but that only knows other celebrities.
At least one celebrity is present at the party.
Write an ASP program that nd who are the celebrities in this party
graph
Adam knows {Dan, Alice, Peter, Eva}
Dan knows {Adam, Alice, Peter}
Eva knows {Alice, Peter}
Alice knows {Peter}
Peter knows {Alice}
⇒ pas de contraintes ensemblistes ici !
Solution
T. Guyet Tuto ASP
26 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Les agrégats
Les agrégats sont des directives qui s'appliquent sur les ensembles
Supported Functions :
min : minimum des termes
max : maximum des termes
#sum : sommes des termes
#count : nombre de termes
#
#
Exemple
Récupération d'une valeur
1
2
p (1..3) .
q(X) :− X = #sum{Y:p(Y)}.
T. Guyet Tuto ASP
27 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Utilisation de min/max
Attention avec les agrégats
l'instanciation d'un agrégat peut conduire à une explosion
combinatoire (à l'instanciation) des valeurs pour identier
l'extremum recherché
il est parfois plus judicieux d'identier les extremums manuellement
Trouver la plus grande ville
Solution avec un #max
plusgrandeville (V) :− ville (V,P), P = #max{Q : ville(U,Q)}.
Solution "ensembliste" (pas de ville plus grande que la plus grande)
plusgrandeville (V) :− ville (V,P),
{
ville (U,Q):Q>P} 0 .
Solution astucieuse (attention : entre
;
et , )
plusgrandeville (V) :− ville (V,P); not ville (U,Q):Q>P,ville(_,Q), ville (U,_).
T. Guyet Tuto ASP
28 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Optimisation des solutions
Sélection des modèles optimaux
Il est possible de sélectionner les modèles selon un (ou plusieurs) critères
d'optimisation.
Directives d'optimisation
maximize
#
#minimize
hd (1..5) }1.
cost (1,250) . cost (2,500) . cost (3,750) . cost (4,1000) . cost (5,1000) .
e (1,20) . e (2,40) . e (3,75) . e (4,80) . e (5,70) .
1{
#
#
minimize{ C@1 : cost(X,C),hd(X) }.
maximize{ C@2 : cost(X,C),hd(X) }.
Appels de clingo
clingo 0 optimisation.lp : donne les modèles intermédiaires
jusqu'à trouver un optimum
clingo 0 optimisation.lp opt-mode=optN : donne tous les
modèles optimaux
T. Guyet Tuto ASP
29 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Cycle de Hamilton minimal
Coût des cycles
chaque arc est associé à un poid (le distance entre deux villes)
on cherche à identier le chemin de moindre coût
Contraintes de minimisation
Ajout aux programmes précédents :
cost (SC) :− SC= #sum{C: edge(X,Y,C),cycle(X,Y)}.
#minimize {C@1 : cost(C)}.
Evaluations
clingo france.lp hamilton_v3.lp hamilton_optim.lp
Temps de résolution
v1 : 880.122s
v2 : 401.177s
v3 : 190.654s
Longueur minimale du cycle : 2733
T. Guyet Tuto ASP
30 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Outline
1
ASP
2
Syntaxe ASP par la pratique
3
Clustering avec ASP
4
Interfaçage Python/clingo
5
Conclusion
T. Guyet Tuto ASP
31 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Clustering : approche déclarative
Description de la tâche
La classication non supervisée, ou clustering, est un problème
d'optimisation
mono-objectif : minimisation du diamètre maximal des clusters D ou
maximisation de la marge entre clusters S
bi-objectif : (max(S ), min(D ))
Approche de Dao et al. basée sur la programmation par contraintes
[TBHD14].
Vers une implémentation ASP
On donne une base de faits
dist (X,Y,C) : distance C entre les objets X et Y, Y>X (voir chier
dist_iris.lp).
#const k=3. : dénition du nombre souhaité de classes (constante)
T. Guyet Tuto ASP
32 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Exercice
Dénir les nouveaux faits utiles à la résolution : cluster /1, objet /1.
Dénition de la partition ∆ : règle de choix pour l'attribution d'un
objet à un cluster (prédicat att /2)
Contraindre un cluster à avoir au moins 2 éléments
Dénir une règle pour le calcul du diamètre de la partition diametre/1.
D (∆) =
max
c ∈[1,k ],(oi ,oj )∈Cc
d (oi , oj )
Dénir une règle pour le calcul de la marge de la partition
M (∆) =
1≤
min
c <c 0 ≤k ,oi ∈Cc ,oj ∈Cc 0
d (oi , oj )
Écrire les directives d'optimisation des critères : min∆ D (∆),
max∆ M (∆)
Solution
T. Guyet Tuto ASP
33 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Ajout de contraintes utilisateurs sur le clustering
Contraintes de type must-link, cannot-link
:−
:−
att (C,X), att (C,Y), cannotlink (X,Y).
att (C1,X), att (C2,Y), C1!=C2, mustlink(X,Y).
→ nécessite de dénir des faits correspondant aux prédicats cannotlink /2.
et mustlink /2.
Contraintes de diamètre maximal/marge minimale
∀c ∈ [1, k ], ∀oi , oj ∈ Cc , d (oi , oj ) ≤ γ ,
∀c ∈ [1, k ], c 0 6= c , ∀oi ∈ Cc , oj ∈ Cc 0 , d (oi , oj ) ≥ δ
const delta=40.
#const gamma=500.
:− att ( C,X), att ( C,Y), d(X,Y,D), X<Y, D>gamma.
:− att ( C1,X), att ( C2,Y), C1!=C2, d(X,Y,D), D<delta.
#
T. Guyet Tuto ASP
34 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Outline
1
ASP
2
Syntaxe ASP par la pratique
3
Clustering avec ASP
4
Interfaçage Python/clingo
5
Conclusion
T. Guyet Tuto ASP
35 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Clingo4 : ASP + Control
clingo4 cherche à répondre à des problèmes où la connaissance est
apportée de manière dynamique [GKKS14]
Les caractéristiques principales de cet environnement sont :
l'interfaçage avec des langages de scripts : Lua et Python
la possibilité de déclarer des sous-programmes (paramétré)
le contrôle de l'exécution via deux instructions de base ground et
solve ; accès à des variables externes
http://potassco.sourceforge.net/gringo.html
Détail technique !
L'utilisation des fonctionnalités de script avec Python nécessite de
compiler sa version de clingo.
Usage pratique
récupération de statistiques complémentaires
automatisation du chargement d'une base de faits
récupération structurée des sorties de la résolution
T. Guyet Tuto ASP
36 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Interfaçage Python embedding
Directive de script
La directive #script permet d'inclure du code Python dans un programme
ASP, dans ce cas la fonction main(prg) du programme dénit la procédure
de résolution
prg . ground([("base",
[]) ])
: instanciation
prg . solve () : résolution
script (python)
import gringo
def id (x) :
return x
def seq(x , y) :
return [ x , y ]
script (python)
import gringo
#
def main(prg):
prg . ground([("base",
prg . solve ()
#end.
p(@id(10)) .
q(@seq(1,2)) .
T. Guyet Tuto ASP
#
def onModel(model):
print model
[]) ])
def main(prg):
prg . ground([("sousp", [5]) ])
prg . solve (on_model=onModel)
#end.
program sousp(n).
q (1.. n) .
#
37 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Interfaçage Python intégration Python
Inclusion de résolution dans un programme Python
Possibilité d'inclure des résolution ASP au sein d'un programme
Python
Permet de développer des outils intégrant clingo
from gringo import ∗
def onModel(model):
print model
ctl = Control()
ctl . load ("./structures/patterns.lp")
ctl . ground([("base", []) ])
ctl . solve (on_model=onModel)
print ( json . dumps(ctl. stats , sort_keys=True, indent=4, separators=(',', ': ')))
Exemples
clingo quiet=2,2 classif_embedded.lp
python classif_embedded.py a
a. nécessite un export
T. Guyet Tuto ASP
PYTHONPATH=.
38 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Outline
1
ASP
2
Syntaxe ASP par la pratique
3
Clustering avec ASP
4
Interfaçage Python/clingo
5
Conclusion
T. Guyet Tuto ASP
39 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Sur le langage ASP
Les possibilités du langage sont en fait plus complexes mais au-delà
des possibilités d'une introduction
Notons qu'il est possible d'utiliser la négation classique en utilisant le
moins (e.g −p:− q.)
La modélisation ASP reste un art délicat !
les bonnes modélisations s'appuient sur des représentations concises,
limitant les symmetries
des améliorations peuvent être apportées par des astuces
(e.g. attention aux aggrégats !)
l'approche expérimentale est de mise !
T. Guyet Tuto ASP
40 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Sur la suite Potassco
clingo en version 4 est un logiciel fonctionnel et ecace (cette
version est prévue pour être stable)
De nombreuses options sont encore à découvrir :
choix des heuristiques de résolution
utilisation de la parallélisation
la résolution incrémentale (avec Python)
la suite logicielle s'accompagne d'autres outils spéciques
moteurs hybrides (asprin, aspartame)
solveurs expérimentaux (aclasp)
les grandes possibilités d'interfaçage sont très intéressantes en
pratique (Python, Lua ou C++)
T. Guyet Tuto ASP
41 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
L'ASP c'est utile quand ?
Pour ..
Techniquement, ASP ore un cadre unié pour 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 dié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 coeur de cible d'ASP. En
particulier c'est un candidat de choix pour attaquer des problèmes NP-complets
et NP-diciles (graphes, raisonnement, ...) du fait de la facilité de mettre au
point et tester diérents modèles et diérentes heuristiques .
Contre ...
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. Embarquer des scripts Python pour les pré et post-traitements ;
travailler dans des espaces peu structurés et peu contraints ou des espaces
diciles à 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.
T. Guyet Tuto ASP
42 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Ressources complémentaires
http://potassco.sourceforge.net/teaching.html
⇒ cours, tutoriaux et références de Potassco
⇒ vidéos d'utilisation de clingo
⇒ listes de diusion de clingo (active)
Answer Set Solving in Practice, by Martin Gebser, Roland Kaminski,
Benjamin Kaufmann, and Torsten Schaub, Morgan and Claypool
[GKKS12] ( ! !clingo 3 ! !)
T. Guyet Tuto ASP
43 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
ASP nos applications phares
Fouille déclarative de motifs
Adaptation des tâches classiques de fouille de motifs
itemsets, séquences, ux de données
variantes des motifs : clos, maximaux
motifs émergents
Utilisation de connaissances expertes sur les données
Extraction d'un sous-ensemble de motifs optimaux
k -patterns sets
dominant patterns
Application à la caractérisation de parcours de soins
Utilisation d'ASP
proposition de modélisation des tâches
ajout de connaissances dans le processus de fouille
utilisation de Python pour les entrées/sorties
exploration de modélisation ecace (with T. Schaub et al.)
T. Guyet Tuto ASP
44 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
ASP nos applications phares
Simulation des paysages agricoles
Recomposition des occupations du sol pour un parcellaire agricole
Formalisation par un problème de couverture de graphe contraint par
des structures (graph-packing )
Ajout de contraintes expertes complémentaires
Utilisation d'ASP
résolution d'un problème de graph-packing
symmetry breaking : approches génériques
intégration du solveur dans des scripts python (interfaces en cours)
T. Guyet Tuto ASP
45 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
Merci de votre attention !
Ce support s'inspire des présentations de J. Nicolas (Inria/Dyliss) et de
T. Schaub (Potassco). Mes remerciements vont également à Y. Moinard
qui m'a mis le pied à l'étrier.
T. Guyet Tuto ASP
46 / 53
ASP
Syntaxe ASP par la pratique
Clustering avec ASP
Interfaçage Python/clingo
Conclusion
References
References I
M. Gebser, R. Kaminski, B. Kaufmann, and T. Schaub, Answer set solving in practice, Synthesis Lectures
on Articial Intelligence and Machine Learning, Morgan and Claypool Publishers, 2012.
Martin Gebser, Roland Kaminski, Benjamin Kaufmann, and Torsten Schaub, Clingo = ASP + control :
Preliminary report, CoRR abs/1405.3694 (2014).
Vladimir Lifschitz, What is answer set programming ?, Proceedings of the Twenty-Third AAAI Conference
on Articial Intelligence, AAAI 2008, Chicago, Illinois, USA, July 13-17, 2008 (Dieter Fox and Carla P.
Gomes, eds.), AAAI Press, 2008, pp. 15941597.
C Vrain T.-B.-H. Dao, K.-C. Duong, Classication non supervisée mono et bi-objectif par la programmation
par contraintes, Dixièmes Journées Francophones de Programmation par Contraintes (JFPC), 2014.
T. Guyet Tuto ASP
47 / 53
Annexes
Statistiques Cycle Hamiltonien - v1
Retour
Models
Calls
Time
CPU Time
:
:
:
:
5040
1
0.384s (Solving: 0.38s 1st Model: 0.00s Unsat: 0.01s)
0.380s
Choices
Conflicts
Restarts
Model-Level
Problems
Lemmas
Binary
Ternary
Conflict
Loop
Other
:
:
:
:
:
:
:
:
:
:
:
13977
8586
235
8.3
1
6921
10
29
6921
0
0
:
:
:
:
:
:
490
1344
369
649
No
232
Atoms
Rules
Bodies
Equivalences
Tight
T. Guyet
Tuto ASP
Variables
(Analyzed: 6921)
(Average: 29.45 Last: 246)
(Average Length: 0.00 Splits: 0)
(Deleted: 0)
(Ratio: 0.14%)
(Ratio: 0.42%)
(Average Length: 17.3 Ratio: 100.00%)
(Average Length:
0.0 Ratio:
0.00%)
(Average Length:
0.0 Ratio: 0.00%)
(1: 496/1280 2: 120/8 3: 56/56)
(Atom=Atom: 184 Body=Body: 0 Other: 465)
(SCCs: 1 Non-Hcfs: 0 Nodes: 71 Gammas: 0)
(Eliminated:
0 Frozen: 120)
48 / 53
Annexes
Statistiques Cycle Hamiltonien - v2
Retour
Models
Calls
Time
CPU Time
:
:
:
:
5040
1
0.038s (Solving: 0.03s 1st Model: 0.00s Unsat: 0.00s)
0.030s
Choices
Conflicts
Restarts
Model-Level
Problems
Lemmas
Binary
Ternary
Conflict
Loop
Other
:
:
:
:
:
:
:
:
:
:
:
5975
925
29
5.3
1
226
0
0
226
0
0
:
:
:
:
:
:
298
432
169
473
No
136
Atoms
Rules
Bodies
Equivalences
Tight
T. Guyet
Tuto ASP
Variables
(Analyzed: 226)
(Average: 7.79 Last: 220)
(Average Length: 0.00 Splits: 0)
(Deleted: 0)
(Ratio: 0.00%)
(Ratio: 0.00%)
(Average Length: 12.9 Ratio: 100.00%)
(Average Length:
0.0 Ratio:
0.00%)
(Average Length:
0.0 Ratio: 0.00%)
(1: 288/400 2: 32/16 3: 16/16)
(Atom=Atom: 200 Body=Body: 0 Other: 273)
(SCCs: 1 Non-Hcfs: 0 Nodes: 71 Gammas: 0)
(Eliminated:
0 Frozen: 120)
49 / 53
Annexes
Statistiques Cycle Hamiltonien - v3
Retour
Models
Calls
Time
CPU Time
:
:
:
:
2520
1
0.021s (Solving: 0.02s 1st Model: 0.00s Unsat: 0.00s)
0.020s
Choices
Conflicts
Restarts
Model-Level
Problems
Lemmas
Binary
Ternary
Conflict
Loop
Other
:
:
:
:
:
:
:
:
:
:
:
3077
530
19
10.3
1
282
0
0
282
0
0
:
:
:
:
:
:
298
453
190
473
No
136
Atoms
Rules
Bodies
Equivalences
Tight
T. Guyet
Tuto ASP
Variables
(Analyzed: 282)
(Average: 14.84 Last: 1)
(Average Length: 0.00 Splits: 0)
(Deleted: 0)
(Ratio: 0.00%)
(Ratio: 0.00%)
(Average Length: 14.2 Ratio: 100.00%)
(Average Length:
0.0 Ratio:
0.00%)
(Average Length:
0.0 Ratio: 0.00%)
(1: 309/421 2: 32/16 3: 16/16)
(Atom=Atom: 200 Body=Body: 0 Other: 273)
(SCCs: 1 Non-Hcfs: 0 Nodes: 71 Gammas: 0)
(Eliminated:
0 Frozen: 120)
50 / 53
Annexes
Retour
Le programme ci-dessous est basé sur une génération de tous les
sous-ensembles de chemin, combiné avec les contraintes proposées il est
cependant très ecace (équilavent aux autres).
1 edge(X,Y):− edge(X,Y,_).
2 edge(X,Y,C):− edge(Y,X,C).
3 node(X;Y):− edge(X,Y).
4 start ( brest ) .
5
6 { cycle ( X,Y) } :− edge(X,Y).
7 :− 2 { cycle ( X,Y) : edge(X,Y)}, node(X).
8 :− 2 { cycle ( X,Y) : edge(X,Y)}, node(Y).
9
10 reached(Y):− cycle(X,Y), reached(X).
11 reached(Y):− cycle(X,Y), start ( X).
12 :− node(X), not reached(X).
13
14 #show cycle/2.
T. Guyet Tuto ASP
51 / 53
Annexes
Retour
1 %The party graph
2 knows(adam, (dan;alice ; peter ; eva)) . knows(dan, (adam;alice ; peter )) .
3 knows(eva, ( alice ; peter )) .
4 knows( alice , peter ) . knows(peter, alice ) .
5 %People at the party
6 people(X):−knows(X,_).
7 people(X):−knows(_,X).
8 % A person is unknown if someone else does not know it
9 unknown(U) :− people(P); people(U); U!=P; not knows(P,U).
10 % A person is normal if it knows someone who is not a celebrity
11 normal(P):− people(P); people(U); U!=P; knows(P,U), not celebrity ( U).
12 %A celebrity is a person neither unknown or normal
13 celebrity ( C):−people(C), not unknown(C), not normal(C).
14 %At least one celebrity is present at the party .
15 :− not celebrity ( C):people(C).
16 #show celebrity /1.
T. Guyet Tuto ASP
52 / 53
Annexes
Retour
#
const k=3.
% denition des clusters
cluster
(1..
k) .
% denition des objets a partir des distances
objet (X) :− dist (X,_,_). %projection
T. Guyet Tuto ASP
53 / 53
Annexes
Retour
#
const k=3.
% denition des clusters
cluster
(1..
k) .
% denition des objets a partir des distances
objet (X) :− dist (X,_,_). %projection
% Denition de la partition
% −> choix de l' attribution des objets aux clusters
1{
att (C,X): cluster (C) }1 :− objet (X).
T. Guyet Tuto ASP
53 / 53
Annexes
Retour
#
const k=3.
% denition des clusters
cluster
(1..
k) .
% denition des objets a partir des distances
objet (X) :− dist (X,_,_). %projection
% Denition de la partition
% −> choix de l' attribution des objets aux clusters
1{
att (C,X): cluster (C) }1 :− objet (X).
% au moins deux objets par classes
:−
cluster (C), {att (C,X): objet (X)}1.
T. Guyet Tuto ASP
53 / 53
Annexes
Retour
#
const k=3.
% denition des clusters
cluster
(1..
k) .
% denition des objets a partir des distances
objet (X) :− dist (X,_,_). %projection
% Denition de la partition
% −> choix de l' attribution des objets aux clusters
1{
att (C,X): cluster (C) }1 :− objet (X).
% au moins deux objets par classes
:−
cluster (C), {att (C,X): objet (X)}1.
% Diametre de la partition
diam(D) :− D=#max{ M : dist(X,Y,M), att(C,X), att(C,Y), X<Y, cluster(C) }.
T. Guyet Tuto ASP
53 / 53
Annexes
Retour
#
const k=3.
% denition des clusters
cluster
(1..
k) .
% denition des objets a partir des distances
objet (X) :− dist (X,_,_). %projection
% Denition de la partition
% −> choix de l' attribution des objets aux clusters
1{
att (C,X): cluster (C) }1 :− objet (X).
% au moins deux objets par classes
:−
cluster (C), {att (C,X): objet (X)}1.
% Diametre de la partition
diam(D) :− D=#max{ M : dist(X,Y,M), att(C,X), att(C,Y), X<Y, cluster(C) }.
% Marge de la partition
marge(M) :− M=#min{D : dist(X,Y,D), att(C1,X), att(C2,Y), X<Y, C1!=C2}.
% on ne peut pas mettre C1<C2 a cause de la matrice de distance triangulaire (X<Y)
T. Guyet Tuto ASP
53 / 53
Annexes
Retour
#
const k=3.
% denition des clusters
cluster
(1..
k) .
% denition des objets a partir des distances
objet (X) :− dist (X,_,_). %projection
% Denition de la partition
% −> choix de l' attribution des objets aux clusters
1{
att (C,X): cluster (C) }1 :− objet (X).
% au moins deux objets par classes
:−
cluster (C), {att (C,X): objet (X)}1.
% Diametre de la partition
diam(D) :− D=#max{ M : dist(X,Y,M), att(C,X), att(C,Y), X<Y, cluster(C) }.
% Marge de la partition
marge(M) :− M=#min{D : dist(X,Y,D), att(C1,X), att(C2,Y), X<Y, C1!=C2}.
% on ne peut pas mettre C1<C2 a cause de la matrice de distance triangulaire (X<Y)
%Directives d' optimisation
#
#
minimize{ D@1 : diam(D) }.
maximize{ M@1 : marge(M) }.
T. Guyet Tuto ASP
53 / 53