1/23

Programmation dynamique

2/23

# Policy Evaluation

# Résolution matricielle

Reprenons l'exemple précédent, un environement dans lequel la politique est fixée :

Question: comment calculer la valeur de cette politique ?

3/23

On peut pour chaque état écrire une équation de Bellman. Par exemple, pour l'état B :

V (B) = 1 + γ V (B B)

Ici, l'environnement est particulièrement simple, il n'y a pas de transitions aléatoires.

4/23

On pourrait mettre l'ensemble de ces équations sous forme matricielle :

\underset{V}{\underset{⏟}{[\begin{matrix} V (I) \\ V (B) \\ V (R) \\ V (B B) \\ V (B R) \\ V (R R) \end{matrix}]}} = \underset{R}{\underset{⏟}{[\begin{matrix} 1 \\ 1 \\ 1 \\ 0 \\ 10 \\ 20 \end{matrix}]}} + γ \underset{P}{\underset{⏟}{[\begin{matrix} 0 & 1 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{matrix}]}} \underset{V}{\underset{⏟}{[\begin{matrix} V (I) \\ V (B) \\ V (R) \\ V (B B) \\ V (B R) \\ V (R R) \end{matrix}]}}

Et résoudre le système linéaire :

V = R + γ P V

(I - γ P) V = R

V = (I - γ P)^{- 1} R

5/23

C'est ce que fait le code Python ci-desous.

import numpy as np

states = ["I", "B", "R", "BB", "BR", "RR"]

R = np.array([1., 1., 1., 0., 10., 20.])
P = np.array([
    [0., 1., 0., 0., 0., 0.],
    [0., 0., 0., 1., 0., 0.],
    [0., 0., 0., 0., 1., 0.],
    [0., 0., 0., 0., 0., 0.],
    [0., 0., 0., 0., 0., 0.],
    [0., 0., 0., 0., 0., 0.],
])
gamma = 1.

V = np.linalg.pinv(np.eye(P.shape[0]) - gamma*P) @ R

for name, v in zip(states, V):
    print("V[%s] = %.5f" % (name, v))

6/23

Qui produira la sortie suivante:

V[I] = 2.00000
V[B] = 1.00000
V[R] = 11.00000
V[BB] = 0.00000
V[BR] = 10.00000
V[RR] = 20.00000

Cette solution fonctionne, mais est particulièrement inefficace. En effet, la complexité de l'inversion d'une matrice est en $O (n^{3})$ , ce qui est très coûteux.

7/23

# Solution itérative

Dans la pratique, on utilisera plutôt une solution itérative. On initialise la valeur de chaque état à 0, puis on répètera la mise à jour suivante :

V (s) \leftarrow \sum_{s^{'}} P (s^{'} | s, π (s)) [R (s^{'} | s, π (s)) + γ V (s^{'})]

Pour chaque état. L'algorithme continuera jusqu'à ce que $V (S)$ ne change plus.

8/23

L'algorithme peut alors s'écrire :

Reinforcement learning: an introduction, second edition, page 97

Dans l'algorithme ci-dessus, la politique est elle aussi aléatoire, d'où l'apparition de $π (a | s)$ , la probabilité de choisir l'action $a$ depuis l'état $s$ . Par simplification nous n'avons pas réglé ce cas.

9/23

# Exemple

Exécutons cet algorithme sur le problème de l'étudiant :

En vert, la fonction de valeur est initialement à $0$ partout. En violet, on représente l'ordre de parcours des états utilisé dans le for each (cet ordre a une importance dans l'algorithme).

10/23

Voici les itérations successives :

11/23

Après 2 itérations, la fonction de valeur a déjà convergé, plus aucune mise à jour n'est nécessaire.

12/23

# Amélioration d'une politique

# Politique gourmande

Pour une fonction de valeur $V$ donnée, on appellera la politique gourmande ${\hat{π}}^{V}$ la politique qui choisit toujours l'action qui maximise la fonction de valeur à l'étape suivante :

{\hat{π}}^{V} (s) = \arg max_{a} \sum_{s^{'}} P (s^{'} | s, a) [R (a, s, s^{'}) + γ V (s^{'})]

13/23

Exemple

En repartant de l'itération 2 ci-dessus, obtenue par l'évaluation d'une politique (médiocre) dans l'environnement de l'étudiant :

On pourrait construire une nouvelle politique en appliquant la logique gourmande pour chaque état. Par exemple, pour l'état R, on a le choix entre:

Action boire: $r = 1$ , état d'arrivé BR, retour estimé $1 + V (B R) = 11$
Action reviser: $r = 0$ , état d'arrivé RR, retour estimé $0 + V (R R) = 20$

C'est donc cette deuxième action qui est choisie.

14/23

Intuitivement, l'évaluation "propage" la valeur à travers l'environnement, et l'amélioration de la politique modifie la politique pour choisir les actions qui maximisent cette valeur.

15/23

# Policy Iteration

# Intuition

Nous avons maintenant deux opérateurs:

Policy evaluation:

Calcul de $V^{π}$ , la fonction de valeur d'une politique $π$ ,

Policy improvement:

Calcul de ${\hat{π}}^{V}$ , la politique gourmande d'une fonction de valeur $V$ .

16/23

Nous pouvons donc suivre l'algorithme suivant :

Initialiser une fonction de valeur $V$ à $0$
Calculer la politique gourmande ${\hat{π}}^{V}$
Calculer la nouvelle fonction de valeur $V^{'}$ de la politique ${\hat{π}}^{V}$
Définir $V = V^{'}$ , et répéter les étapes 2 et 3 jusqu'à convergence

17/23

# Politique optimale

Bonne nouvelle

En suivant cette alternance (évaluation/amélioration), nous sommes assurés de converger vers une politique optimale.

C'est un schéma que nous retrouverons dans tous les algorithmes d'apprentissage par renforcement.

18/23

# Algorithme

Reinforcement learning: an introduction, second edition, page 102

19/23

# Value Iteration

L'algorithme de policy iteration nécessite une alternance entre calcul de la politique gourmande et calcul de la fonction de valeur. Il est nécessaire d'obtenir la fonction de valeur avant de pouvoir calculer la nouvelle politique gourmande.

Une amélioration possible est de mettre (virtuellement) à jour la politique gourmande à chaque itération de la fonction de valeur. C'est ce que fait l'algorithme de value iteration.

20/23

Reinforcement learning: an introduction, second edition, page 105

21/23