3.1.1 ´ Ecriture des contraintes logiques en probl` eme SAT-CNF . 148

Les contraintes logiques d´efinies dans cette th`ese sont au format DNF. En effet, les

contraintes sont des conjonctions de litt´eraux (D´ef. 17), et ces contraintes sont li´ees par

une disjonction (´Eq. III.7).

Un ensemble de contraintes logiques est d´efini comme satisfait, lorsque l’ensemble des

contraintes est satisfait (D´ef. 24). De plus, une contrainte est satisfaite lorsqu’elle est

´

evalu´ee `a faux. Par cons´equent, en reprenant la notation utilis´ee dans la d´efinition 11

(probl`eme SAT satisfaisable), il est possible de montrer qu’un ensemble de contraintes

logiques est ´equivalent `a un probl`eme SAT-CNF :

Filtre logique satisfait ⇔

dim(C)

X

i=1

Y

j

`

_j

= 0

⇔

dim(C)

X

i=1

Y

j

`

_j

= 1

⇔

dim(C)

Y

i=1

X

j

`

_j

= 1

⇔SAT-CNF satisfaisable

Avec cette transformation, il est donc possible d’utiliser un solveur SAT-CNF pour

im-pl´ementer le filtre logique. N´eanmoins, le filtre logique, et donc le solveur SAT-CNF, a

pour objectif d’ˆetre utilis´e en«temps r´eel»dans un API afin de commander un syst`eme

de production. Il est donc essentiel de garantir qu’il existera toujours une solution au

pro-bl`eme. Dans le cas contraire, l’API se retrouvera en d´efaut `a cause du d´eclenchement d’un

IV-3 Commande par filtre logique `a base de techniques SAT 149

garanties correctes. N´eanmoins, si l’ensemble de contraintes est coh´erent alg´ebriquement,

l’existence d’une solution est garantie.

Dans le cas de l’utilisation d’un solveur SAT pour la commande par filtre logique, les

priorit´es n’ont pas `a ˆetre utilis´ees. En effet, celles-ci permettent de forcer la mani`ere de

r´esoudre une contrainte combin´ee (r´esolution «statique»). Or, dans le cas d’un solveur

SAT, ce sont les techniques de propagations et les heuristiques utilis´ees, qui

permet-tront de choisir une solution de fa¸con «dynamique»pour les contraintes combin´ees. Par

cons´equent, il est possible de garantir qu’il existera toujours une solution (affectation des

sorties), quelles que soient les affectations en entr´ees, en v´erifiant la propri´et´e de coh´erence

alg´ebrique (D´ef. 30).

IV-3.1.2 Utilisation d’un solveur SAT en python pour la commande par filtre

logique

Le laboratoire CReSTIC collabore depuis 2008, dans le cadre d’un partenariat de

re-cherche et d´eveloppement, avec la soci´et´e Real Games

¹

. Cette soci´et´e propose des

logi-ciels de simulations 3D de parties op´eratives (ITS PLC, FACTORY I/O, HOME I/O).

Ces logiciels ont la particularit´e de pouvoir ˆetre connect´es simplement `a un environnement

ext´erieur, pour le contrˆole des parties op´eratives (programme C#, Python, automate

pro-grammable...). La preuve de concept propos´ee utilise le logiciel ITS PLC connect´e `a un

programme Python.

Diff´erents solveurs CSP et SAT sont disponibles en Python : logilab-constraint

²

,

pyco-sat

³

... Logilab-constraint est d´evelopp´e enti`erement en Python, contrairement `a d’autres

(comme pycosat) qui sont des interfaces pour d’autres solveurs d´evelopp´es dans des

langages diff´erents. Logilab-constraint permet de d´efinir simplement les variables et

les contraintes. De plus, il est possible de sp´ecifier, pour une contrainte donn´ee, un

sous-ensemble de variables modifiables, les autres variables seront consid´er´ees comme

constantes pour la r´esolution. Enfin, logilab-constraint est un solveur CSP, mais il est

possible de l’utiliser en tant que solveur SAT.

1. https://realgames.co/

2. https://www.logilab.org/project/logilab-constraint

L’utilisation de ces outils logiciels pour r´ealiser cette preuve de concept est pr´esent´ee sur

la figure 47.

Programme Python Lecture entrées Sorties souhaitées Programme fonctionnel Ensemble de solutions Solveur SAT Choix d'une solution Écriture sorties ITS PLC

Figure 47 – Partie op´erative simul´ee contrˆol´ee par un programme Python

Le syst`eme utilis´e est un tri de caisses, il est instrument´e de 11 capteurs et 7 actionneurs.

Une description compl`ete du syst`eme, le programme fonctionnel sp´ecifi´e en Grafcet, et

les contraintes logiques garantissant la s´ecurit´e du syst`eme sont disponibles dans Pichard

et al. (2016). La communication entre le programme Python et ITS PLC est cyclique.

c’est-`a-dire que suite `a une lecture des entr´ees (capteurs), le programme Python s’ex´ecute

enti`erement, puis les sorties (valeurs actionneurs) sont envoy´ees au simulateur.

Le principe est donc de calculer, `a chaque cycle, un vecteur de sorties souhait´ees respectant

les sp´ecifications fonctionnelles. Puis, consid´erant les valeurs mises `a jour des entr´ees et

des observateurs logiques, d’utiliser un solveur SAT pour calculer l’ensemble des vecteurs

de sorties ne violant aucune contrainte logique. Enfin, un choix parmi l’ensemble des

solutions du solveur doit ˆetre effectu´e. Nous proposons d’utiliser la distance de Hamming,

entre le vecteur de sorties souhait´ees et chacune des solutions du solveur, afin de fournir

un indicateur.

La distance de Hamming entre deux mots binaires, est un entier. Cet entier indique le

nombre de bit diff´erents entre les deux mots. Par cons´equent, plus la distance de Hamming

est faible, plus la solution du solveur est proche du vecteur souhait´e. Le vecteur final de

sorties, envoy´e au syst`eme, est donc la solution du solveur ayant la distance de Hamming

la plus faible avec les sorties souhait´ees. En cas d’´egalit´e, la premi`ere calcul´ee est utilis´ee.

IV-3 Commande par filtre logique `a base de techniques SAT 151

Exemple 8. Distance de Hamming

— Hamming(1011101, 1001001) = 2 ;

— Hamming(001, 001) = 0 ;

Cette heuristique de choix a ´et´e utilis´ee pour sa facilit´e d’utilisation et d’interpr´etation.

De plus, il peut ˆetre consid´er´e que le vecteur souhait´e est proche d’une solution. En effet,

celui-ci provient d’un programme fonctionnel (int´egrant les sp´ecifications fonctionnelles)

r´ealis´e par un automaticien.

Le programme Python complet, pour cet exemple, est disponible dans l’annexe IV-1. Voici

la structure globale de ce programme :

— initialisation des variables et calcul des fronts associ´es aux entr´ees/sorties ;

— d´efinition de la fonction de choix (distance de Hamming) ;

— traduction du Grafcet ;

— calcul des observateurs logiques ;

— calcul des fonctions de for¸cage simples ;

— calcul du vecteur de sorties souhait´ees ;

— ajout des variables et des contraintes au solveur ;

— calcul de l’ensemble des solutions par le solveur ;

— choix de la solution finale ;

— mise `a jour des sorties `a envoyer au syst`eme.

Le temps de cycle maximum, enregistr´e pour cet exemple, et de 16ms. C’est un temps de

cycle coh´erent avec les temps de cycles classiques des API, ainsi qu’avec la dynamique du

syst`eme utilis´e. Le fonctionnement observ´e du syst`eme semble tr`es proche de celui observ´e,

avec l’impl´ementation du filtre logique pr´esent´ee pr´ec´edemment (algorithme it´eratif et

priorit´es). N´eanmoins, diff´erents avantages (+) et inconv´enients (-) sont `a souligner `a

l’issue de cette preuve de concept :

Avantages :

+ le crit`ere de choix d’une solution n’est pas bas´e sur des priorit´es arbitraires entre

actionneurs ;

→ l’heuristique de choix peut permettre de prendre en compte des

optimisa-tions globales li´ees `a des probl´ematiques de production

+ ´etant donn´e que les priorit´es ne sont pas n´ecessaires, le probl`eme de la coh´erence

des contraintes est restreint `a la coh´erence alg´ebrique (D´ef. 30) ;

→la phase de conception des contraintes est donc acc´el´er´ee car la v´erification

de la coh´erence alg´ebrique est moins complexe que la coh´erence globale

Inconv´enients:

- le solveur utilis´e est en Python et utilise les ressources de calcul d’un ordinateur

classique ;

→un API poss`ede des ressources de calcul inf´erieur `a un ordinateur classique,

le temps de cycle risque donc d’ˆetre plus long sur un API

→il n’existe pas, `a notre connaissance, de solveur CSP ou SAT impl´ementable

dans un des 5 langages normalis´es des API

- le vecteur de sorties souhait´ees est utilis´e apr`es avoir calcul´e l’ensemble des solutions

du solveur

→ mˆeme si la premi`ere solution calcul´ee est la meilleure, l’ensemble des

solu-tions sont calcul´ees

Dans la suite de cette section IV-3, sont pr´esent´ees deux propositions (sections IV-3.2 et

IV-3.3) permettant d’impl´ementer un solveur SAT dans un API. Les deux propositions

sont bas´ees sur une technique de recherche locale, c’est-`a-dire qu’ils partent d’une premi`ere

affectation des variables afin de trouver une solution (Selmanet al., 1995). Ces propositions

utilisent ´egalement la distance de Hamming comme heuristique de choix. La diff´erence

fondamentale entre ces deux propositions est l’utilisation du back-tracking pour la seconde

(section IV-3.3) et non pour la premi`ere (section IV-3.2).

IV-3.2 Algorithme de recherche locale bas´ee sur la distance de

Hamming

Cet algorithme de recherche locale, ainsi qu’une impl´ementation en ST (IEC61131-3,

2013), ont ´et´e pr´esent´es dans Pichard et al. (2018a). L’objectif est de tester, `a chaque

cycle automate, une affectation des variables de sorties (vecteur G).

IV-3 Commande par filtre logique `a base de techniques SAT 153

Le but de cet algorithme est de trouver un vecteur (solution), `a partir d’une affectation

initiale (FOV) satisfaisant toutes les contraintes. Il est `a noter que cet algorithme est

appel´e `a chaque cycle automate. Par cons´equent, son ex´ecution doit ˆetre rapide (quelques

millisecondes). Si au moins une contrainte est viol´ee par G, de nouvelles valeurs doivent

ˆ

etre calcul´ees pour les actionneurs (vecteur solution). Les valeurs des capteurs, et des

observateurs logiques, sont group´ees dans le vecteur Y.

L’id´ee principale est de trouver des valeurs de sorties les «plus proches» du vecteur

G (i.e. changeant le minimum de valeurs). Ceci est effectu´e en utilisant la distance de

Hamming. En effet, l’algorithme commence par tester tous les vecteurs ayant une distance

de Hamming ´egale `a 1, puis 2, puis 3, etc.

Afin d’am´eliorer l’efficacit´e de la recherche, deux vecteurs sont test´es simultan´ements :

closest(Hamming distance minimale),farthest(Hamming distance maximale). Le vecteur

farthest est obtenu en compl´ementant le vecteur closest. Si le vecteur closest r´esout le

probl`eme, l’algorithme est arrˆet´e et closest est utilis´e comme solution. Sinon, si farthest

r´esout le probl`eme, il est sauvegard´e et la recherche recommence avec deux nouveaux

vecteurs.

Avec cette approche, si l’espace d’´etat `a explorer comporte N ´etats, seuls ^N

2 ^boucles

seront n´ecessaires. A la fin de ces boucles, si le vecteur closest ne permet pas de r´esoudre

le probl`eme, alors le dernier vecteur farthest m´emoris´e est utilis´e comme solution. En

effet, ce dernier vecteur farthest m´emoris´e est celui avec la distance de Hamming la plus

faible. L’algorithme 3 synth`ese cette proposition.

A titre d’exemple, une impl´ementation de cet algorithme, en langage ST, est disponible en

annexe IV-2. L’exemple utilis´e est le mˆeme tri de caisses que celui utilis´e dans la section

pr´ec´edente (section IV-3.1). L’impl´ementation propos´ee int`egre le programme Grafcet

tra-duit en ST, les contraintes ainsi que les fonctions de for¸cage. Enfin, certaines fonctions

sont d´efinies pour all´eger l’´ecriture, celles-ci sont list´ees et d´etaill´ees `a la fin de l’impl´

e-mentation. Le programme ST d´etaill´e en annexe IV-2, a ´et´e impl´ement´e dans un API

r´eel (Schneider Electric M340). La plus grande distance de Hamming enregistr´ee pour cet

exemple, entre le vecteur d’entr´ee et le vecteur de sortie, a ´et´e de 2. Enfin, l’ex´ecution du

programme de r´esolution a toujours ´et´e inf´erieur `a 1 ms (Pichard et al., 2018a).

Algorithme 3 : Recherche locale `a base de distance de Hamming

Input :G, Y

Output :solution

Calculer les valeurs des F0s et F1s ;

solution := initialiser la solution en appliquant F0s et F1s au vecteur G ;

Tester les contraintes combin´ees (Cc) avec la solution ;

if au moins une Cc est viol´ee then

index := trouver les index des variables commandables non-forc´ees ;

fork = 1 `a dim(index)/2 do

closest := calculer le premier vecteur le plus proche de G ;

Tester les Cc avec closest ;

if au moins une Cc est viol´ee then

farthest := calculer le premier vecteur le plus loin de G en inversant closest ;

Tester les Cc avec farthest ;

farthestSolution := stocker farthest si il est solution (Cc r´esolues) ;

repeat

if un nouveau vecteur `a tester existe then

closest := calculer le vecteur le plus proche suivant ;

Tester les Cc avec closest ;

if au moins une Cc est viol´ee then

farthest := calculer le vecteur le plus loin de G en inversant closest ;

Tester les Cc avec farthest ;

farthestSolution := stocker farthest si il est solution (Cc r´esolues) ;

end

end

if closest r´esout les Ccthen

solution := closest ;

exit ;

end

untille probl`eme est r´esolu ou tous les vecteurs possibles ont ´et´e test´es;

end

end

if closest ne r´esout pas les Ccthen

if farthest r´esout les Ccthen

solution := farthest ;

else

solution := inverser dans G les valeurs des variables commandables non-forc´ees ;

end

end

end

IV-3 Commande par filtre logique `a base de techniques SAT 155

Pour conclure, cet algorithme permet de trouver une affectation des variables de sorties,

la plus proche au sens de la distance de Hamming, d’une affectation initiale des variables.

´

Etant donn´e que seules les contraintes sont utilis´ees (sans les priorit´es), il suffit de v´erifier

la coh´erence alg´ebrique (D´ef. 30), afin de garantir qu’il existera toujours une solution.

N´eanmoins, cet algorithme n’utilise aucune technique «classique» utilis´ee par les

sol-veurs SAT : propagation de contraintes, back-tracking, apprentissage de clauses... Par

cons´equent, dans le pire des cas l’ensemble de la table de v´erit´e doit ˆetre parcourue, la

complexit´e est alors exponentielle par rapport au nombre de variables. Dans la section

suivante (section IV-3.3), nous proposons un algorithme, impl´ementable dans un API,

uti-lisant de la propagation de contraintes et du back-tracking afin d’optimiser la recherche

d’une solution.

Dans le document Contribution à la Commande des Systèmes à Événements Discrets par Filtre Logique (Page 149-156)