IV.2 Implémentation et preuve de validité d’un algorithme de résolution en program-
IV.2.2 Pré-traitement spécifique aux contraintes non-transitoires ou à horizons finis 86
Comme nous l’avons vu, l’exemple de la figure (Figure 13 page 80) suggère que la valeur d’une politique peut être améliorée dès lors qu’on prend en compte l’historique de l’exécution du système dans un SPC MDP. Cependant, pour certains SPC MDP, on peut montrer facilement que la dépendance à l’histoire du système n’est pas nécessaire, et qu’il existe au moins une politique -optimale markovienne pour tout > 0. C’est en particulier le cas lorsque toutes les fonctions booléennes qui sont utilisées dans les contraintes de ce SPC MDP sont transitoires [TK12a] (Figure 15 page 86) :
Définition 29 (Fonction booléenne transitoire)
Une fonction booléenne f : S → {true, false} sur les états d’un MDP est transitoire s’il existe des transitions depuis l’ensemble des états où f(s) = true vers l’ensemble des états où f(s0) = false, mais qu’il n’existe aucune transition dans la direction inverse, ou vice-versa.
f=false f=true
F i g u r e 15 – Illustration des fonctions transitoires : f partage les états en deux ensembles disjoints, ayant des transitions dans un seul sens
Il est néanmoins possible de transformer des problèmes où certaines fonctions de certaines contraintes ne sont pas transitoires en des SPC MDP comprenant seulement des fonctions transitoires.
Théorème 6 (Réduction aux fonctions transitoires)
Soit M = hS, A, R, T , s0, γ, ξi un SPC MDP, pour lequel m parmi n contraintes ξ= {ξ1, . . . , ξn} comprennent des fonctions booléennes non transitoires. M peut être transformé en un SPC MDP M0 = hS0, A, R0, T0, s00, γ, ξ0i comprenant uniquement des fonctions transitoires en augmentant l’espace d’états avec une variable par contrainte non transitoire. Cette variable a trois valeurs possibles : (validée, invalidée, indéterminée). Le SPC MDP M0 obtenu a ainsi3m|S| états.
Démonstration : On étend l’espace d’états avec de nouvelles variables zi: pour la contrainte i, cette variable devient 1 (i.e. "validée") lorsque le système entre pour la première fois dans un état où g devient vraie ; elle devient -1 (i.e. "invalidée") lorsque le système entre pour la première fois dans un état où f devient fausse. Par défaut, dans l’état initial et en l’absence de changements, elle vaut 0 (i.e. "indéterminée").
On définit la fonction "δ" comme un vérificateur sémantique pour cette extension : δ(i)
s ((s, z), (s0, z0)) =
true if (zi= 0) & gi(s0) & (z0 i= 1)
true if (zi= 0) & !gi(s0) & !fi(s0) & (z0 i= −1)
true if none above and (zi= z0 i)
f alse else
On modifie la fonction de transition de manière correspondante : on définit S0 = S × {−1, 0, 1}m le nouvel espace d’états et T0((s, z), a, (s0, z0)) = T (s, a, s0) si et seulement si tous les δ(i)
s ((s, z), (s0, z0)) sont vrais. R0,I0et ξ0 sont les fonctions étendues naturellement à S0, en omettant la partie en z de l’état.
Alors hS0, A, R0, T0, I0, γ, ξ0i est un SPC MDP à contraintes transitoires : puisque la somme des issues possibles de la fonction de transition T reste égale à 1, on garde effectivement un SPC MDP correct. Notons qu’en raison de l’augmentation de l’espace d’états, toute politique histoire-indépendante optimale pour M0 doit être transformée en politique histoire-dépendante, qui est optimale pour M.
Ce résultat constitue l’étape préliminaire de notre algorithme permettant de résoudre un SPC MDP, que nous détaillons dans la section suivante. Cette étape permet d’éliminer les fonctions non-transitoires, puis évalue les contraintes dans un passage préliminaire en supprimant les états et actions qui ne les respectent pas de façon évidente.
Notons que bien que cette étape augmente l’espace d’états de façon linéaire en fonction des données d’entrées, il existe des cas où elle est potentiellement une des étapes les plus coûteuses en termes de complexité : comme nous le verrons dans les paragraphes suivants, notre algorithme a une complexité polynomiale en fonction des données d’entrées lorsque l’espace d’états est énuméré. Cependant, ce résultat de complexité n’est plus valide dès lors que l’on considère d’autres formats de données d’entrées, tels que les données d’entrées du MDP d’origine. Ceci est expliqué par l’une des deux raisons suivantes : 1. soit par le fait que la conversion d’un problème quelconque en une instance de SPC MDP nécessite un temps de traduction non-polynomial ou un espace d’états polynomial en fonction de la taille des données,
2. soit par l’étape préliminaire de traduction : pour appliquer notre algorithme, il est nécessaire que toutes les fonctions booléennes soient transitoires, et l’étape de traduction peut nécessiter d’augmenter l’espace d’états de façon polynomiale, en particulier lorsque le nombre de contraintes PCTL à créer dépend directement du nombre d’états.
Cependant, lorsque le nombre de contraintes PCTL est négligeable par rapport au nombre d’états, cette étape de traduction a un impact mineur sur le temps de résolution.
IV.2.3 Description et preuve de validité de l’algorithme
L’algorithme que nous construisons sur ce schéma est appelé SPC VI pour Saturated Path Constraints Value Iteration. La boucle principale est présentée dans l’algorithme suivant (Algorithme 4 page 87).
Algorithm 4:SPC Value Iteration
1 Procédure SPC Value Iteration (S, A, R, T , s0, γ, ξ, , θ);
Entrées : hS, A, R, T , s0, γ, ξi tels que définissants un SPC MDP avec contraintes ξ1, . . . , ξn >0 un paramètre d’optimalité
θ >0 un paramètre de convergence Sorties : π ω-politique -optimale
Variables: ˆS l’ensemble des états explorés
T ipun sous-ensemble des états explorés non étendu
2
3 Convertir les fonctions non-transitoires des contraintes (Théorème 6 page 86) si nécessaire ;
4 Initialiser ˆS:= {s0} ; 5 Initialiser T ip := {s0}; 6 explore( ˆS, T ip) ; 7 for i: 1 . . . n do updateReachability( ˆS, ξi, θ) ; 8 for s ∈ S do A(s) :=n a | ∀s0, T(s, a, s0) > 0 ⇒ s0∈ ˆSo; 9 Initialiser ω := (1−γ)2 Rmax−Rmin ;
10 Calculer Vω par Value Iteration avec l’opérateur ωBell ;
CHAPITRE IV. SATURATED PATH CONSTRAINED MDP
Algorithm 5:Fonction explore( ˆS, T ip)
1 Fonction explore ( ˆS, T ip);
Entrées : ˆS un espace des états explorés
T ipun espace des états explorés et non étendus
Sorties : ˆS espace des états explorables par toutes les politiques non trivialement invalides
2
3 repeat
4 Choisir s ∈ T ip ;
5 if il y a une contrainte ξi = fiU=p∞igi telle que ((pi= 1 & !fi(s)) ou (pi= 0 & gi(s))) then
6 Retirer s de T ip et ˆS ;
7 else
8 for a et s0 tels que T(s, a, s0) > 0 do
9 if s0 n’est pas déjà dans ˆS then
10 Ajouter s0 à T ip et ˆS
11 until T ip= ∅;
Algorithm 6:Fonction updateReachability( ˆS, ξi, θ)
1 Fonction updateReachability( ˆS, ξi, θ); Entrées : ˆS un espace d’états
ξi une contrainte de la forme ξi = fiU=p∞igi
θ un paramètre de convergence Sorties : ˆS espace des états valides
Variables: X et X0 des fonctions de valeur représentant la validité
2 3 Initialiser X, X0 à 0; 4 for s ∈ ˆS do X(s) := gi(s) ; 5 repeat 6 X0 := X; 7 for s ∈ ˆS do 8 if pi = 1 then 9 if !fi(s) then 10 X(s) := 0 11 else 12 X(s) := max a P s0 T(s, a, s0)X(s0) 13 if pi = 0 then 14 if gi(s) then 15 X(s) := 1 16 else 17 X(s) := mina P s0 T(s, a, s0)X(s0) 18 until | X − X0 |max< θ; 19 for s ∈ ˆS do
20 if ((pi= 1) & X(s) < 1 − θ) ou ((pi= 0) & X(s) > θ) then Retirer s de ˆS et supprimer les actions y menant ;
Étape 1 : Traitement des contraintes
Dans la première étape, l’algorithme effectue un pré-traitement sur les fonctions non-transitoires des contraintes (Théorème 6 page 86). Il identifie ensuite les états du SPC MDP qui ne peuvent pas être atteints depuis l’état initial sans violer au moins une des contraintes (Algorithme 5 page 88) (l. 6), les états dans lesquels au moins une contrainte n’est pas satisfaisable, et toutes les actions menant à ces types d’états (Algorithme 6 page 88) ( l. 12 et 17). Comme le montre l’algorithme (Algorithme 6 page 88), on peut effectuer cette recherche de manière itérative par une technique simple de programmation dynamique. Ces actions et états ne peuvent pas faire partie d’une politique valide, ils sont donc retirés du MDP (l. 20), ce qui laisse un espace d’états ˆS réduit et un espace d’actions A(s) pour chaque s ∈ ˆS.
On peut résumer cette partie de l’algorithme de la manière suivante :
– ˆS est obtenu après la fonction explore function, où les états qui violent de manière évidente au moins une contrainte sont mis de côtés.
– A est l’ensemble des actions "valides" et est défini après la fonction updateReachability, dans laquelle une opération de Programmation Dynamique est appliquée successivement pour chacune des contraintes, afin de calculer la valeur (vis-à-vis de la validité) pour la meilleure politique possible dans chaque état. Cette opération est inspirée par [HJ94], où elle est utilisée pour calculer la valeur d’une politique donnée. Les preuves de terminaison et de validité demeurent les mêmes. Ces deux espaces d’états et d’actions forment un IHDR MDP avec les propriétés suivantes : Lemme 5
Pour un SPC MDP, soit ΠAl’ensemble de toutes les politiques possibles sur l’ensemble des états ˆS tels que définis ci-dessus, tel que toute politique π ∈ΠA assigne une probabilité 0 à toute action a 6∈ A(s) pour tout état s ∈ ˆS que cette politique atteint.
1. ΠAcontient toutes les politiques valides.
2. Toute ω-politique avec ω >0 dans ΠA est valide.
Démonstration : Adécrit un ensemble très large de politiques : une action est dans A si et seulement si il existe un chemin démarrant par cette action qui respecte toutes les contraintes. Ce chemin peut être histoire-dépendant, ce qui implique qu’on décrit un ensemble de politiques plus large que l’ensemble des solutions.
La preuve du résultat (1) résulte du fait que toute politique à l’extérieur de ΠA doit utiliser une action a 6∈ A(s) dans au moins un état s ; mais une telle action est invalide, ce qui signifie qu’il n’y a pas de politique aléatoire histoire-dépendante qui valide toutes les contraintes en choisissant l’action a. Par conséquent, une telle politique ne peut pas non plus être valide.
Le résultat (2) découle du fait que puisque ˆSne contient aucun état ou action invalide, toute politique qui effectue une marche aléatoire sur ˆS finira par satisfaire toutes les contraintes de ce SPC MDP.
En donnant plus de détails : si on avait une ω-politique invalide dans cet ensemble, ce serait une politique choisissant uniquement des actions dans A(s) et choisissant au moins chaque action avec une probabilité ω. Puisqu’elle est invalide, on peut affirmer l’une des deux propositions suivantes :
– cette politique atteint un état non autorisé ("f est vraie et p=1" ou "g est vraie et p=0") pour au moins une contrainte, ce qui est impossible puisque l’action correspondante qui nous a fait atteindre cet état ne serait pas dans A(s).
– cette politique violerait une contrainte "p = 1" et n’atteindrait jamais un état où g devient vraie ; ce qui est impossible puisque pour tout état s accessible à partir de l’état initial, il existe un chemin de n état et n actions de A qui mènent à un état s0 où f(s0) est vraie (cette existence est garantie avec une probabilité strictement supérieure à 0, sinon la récompense 1 n’aurait pas été propagée vers cet état s), et que la probabilité de choisir ce chemin est au moins de ωn.
Par conséquent, la sortie de la première étape de l’algorithme est un nouvel espace d’états et un nouvel espace d’actions à partir desquels sont construits toutes les politiques valides possibles, y compris les ω-politiques. Ceci signifie que s’il existe une ω-politique -optimale valide, celle-ci est nécessairement construite à partir de ces "briques".
CHAPITRE IV. SATURATED PATH CONSTRAINED MDP
Étape 2 : Value Iteration basée sur l’opérateur ω-Bellman
La seconde étape de l’algorithme (Algorithme 4 page 87) (l. 8-10) commence par la détermination d’une valeur de ω (l. 9) pour lequel toutes les ω-politiques gloutonnes sur l’espace d’états et l’espace d’actions restants sont -optimales, via le théorème prouvé précédemment (Théorème 5 page 85). L’algorithme itère alors l’opérateur ω-Bellman (l. 10) pour trouver une ω-politique gloutonne qui est -optimale pour le MDP avec les espaces d’états et d’actions réduits. Par construction, comme ce MDP contient toutes les politiques valides, cette politique est -optimale parmi toutes les politiques valides pour le MDP complet. Avec le lemme 5, cette politique est également valide, ce qui nous permet d’obtenir le résultat suivant :
Théorème 7 (Existence d’ω-politiques -optimales)
Pour tout SPC MDP avec des contraintes satisfiables, il existe une politique -optimale valide et l’algorithme SPC VI permet de la trouver. La solution est aléatoire et markovienne dans l’espace d’états augmenté, mais histoire-dépendante dans l’espace d’états d’origine.
Ce résultat fondamental montre ainsi la validité de notre algorithme. Dans la section suivante, nous allons à présent évaluer les performances de cet algorithme sur un ensemble de cas de tests académiques, en particulier en comparant le temps de calcul et la qualité de la solution vis-à-vis des algorithmes existants pour PCMDP.