Apprentissage par renforcement

Apprentissage par renforcement

Module « soft-computing »

Apprentissages

{

Supervisé

{ Symbolique : faits + induction

{ Connexioniste : entrées/sorties + optimisation

{ nécessite : Liste d’exemples

{

Evolutionniste

{ génération évolutionniste de “la solution” + sélection + croisement + mutation

{ nécessite : mesure de la “qualité” (fitness) d’une solution

{

Renforcement

{ Essai/Erreur de la “meilleure prochaine action”

Historique

{

Psychologues : [Thorndike 1911]

{ Animaux

{ État-action -> récompense ou punition

{ Apprentissage des associations état- action

z Force de la récompense

z Fréquence de la récompense

{

Mathématiciens : [Bellman 1957]

{ Optimisation de stratégie de contrôle

La Carotte, le baton et le silence

environnement

Perception

Récompenses Action

mémoire

Apprentissage par renforcement

environnement

Apprentissage par exploration

récompense ou

renforcement but atteint ? perception

actions état

modification

selection

Apprentissage par renforcement

{

Apprentissage d’interactions avec un environnement

{

Environnement pouvant être dynamique

{

Pas d’exemples “tout fait”

{

Exploration / Exploitation

Exemple : Tic Tac Toe

{

Joueur parfait ne perd jamais

{

Joueur imparfait “pas logique”

z modèle parfais du joueur (minmax) exclu

Apprendre le Tic-Tac-Toe

{ Pondérer les états du jeu

z valeur de l’état = récompense

z pondération initiale :

{ 1 pour trois croix alignées

{ 0 pour trois rond alignés

{ 0.5 ou aléatoire pour les autres

{ exploiter : aller vers les états de grande valeur { explorer : partir au hasard

{ apprendre : faire remonter un partie des valeurs de l ’état courant vers les états précédents

Apprendre le Tic-Tac-Toe

0.5

Q=0.8 0.5

exploitation

exploration : aléatoire

0.8 Q’

apprentissage

Q = Q + α(Q ’-Q )

0.3

Ici c’est de l’apprentissage par différence temporelle

Variables clés

Actions A (a_i, a_j …)

Renforcement r (r_k, r_j ..)

π: stratégie R : gain

Etats

π : Stratégies(s)

{

Caractérise ce qu’il faut faire ? s->a

{ probabiliste :

z π(s,a) : probabilité de choix (dure/permissive)

{ déterministe :

z π(s) : action, pas une probabilité

{ π* optimale : permet d ’obtenir le plus de gains

z compromis court/long terme , infini ? épisode ?

π : Stratégie(s)

{

exemple

Stratégie déterministe

actions

Sortie état

Stratégie probabiliste

R : le gain

• Pas de définition unique

{ Gain au bout d’un certain temps

z Jeu chronométré

{ Gain au bout d’un temps “infini”

∑

+ + + + =

= ^T

t i

i T

t t

t r r r r

R

1 2

1 L

Gain cumulé sur horizon fini

Gain cumulé avec intérêt

∑

+

= + +

+ +

+ + + =

=

1

1 3

2 2

1

t k

k t k t

t t

t r r r r

R γ γ ^L γ

Gain en moyenne

Influence de la définition du gain

K = 4 et γ=0.9 3 stratégies

+2

+10

+11

3 définitions de gain

∑= k

t

rt

0 ∑^∞

=0 t

t tr

γ ∑

=

∞

→ k

t t

k r

k ₀ lim 1

6 ^{16 2}

59

11

0

0 58.4

10

Le problème de l’exploration

Les machines à sous

Machine à sous à n bras

z un seul état

z un nombre de tirage fixés

z n bras : n actions a₁…a_n , gain moyen Q(a_i)

z chaque bras permet de gagner une somme r distribuée aléatoirement (proba inconnue)

0000

1 n Proba pour 2 bras

0,1

a1 a2

gain

Machine à sous à n bras

{ Explorer : jouer au pif

{ Exploiter : jouer le meilleur bras estimé

z Estimer l’utilité d’une action a (bras) ?

z Estimation possible seulement après qu’elle soit choisie k_a fois :

Gain estimé pour a =Q_ka(a) = r1+r2+……+rk_a

z si k_a → ∞ alors Q_ka(a) -> Q(a)

k_a

Définition récursive de Q

(a)

k

r r

a r

Q

+ + +

= ...

)

(

1

1 1 1

= ∑ +

+

k

Q r

k

i i

k

] [

1 * 1

1

1 k k k

k

r Q

Q k

Q −

+ +

=

+

]

1

Q .[ erreur Q

=

+ α

1

1 1

1

+

= ∑

+

+

k

r Q r

k

i i t

k

Q

Voir page 46

Problèmes non stationnaires

{

Lorsque Q varie dans le temps

z privilégier les dernières expériences

z problème de convergences

∑

−

+

−

=

i i

i k k

k

Q r

Q ( 1 α )

α ( 1 α )

Bien apprendre : explorer/exploiter

{ Taux d’exploration : ε (ε-Greedy methods)

{ ε variable aléatoire (0≤ ε ≤1) probabilité

{ valeur de ε ?

z apprentissage rapide du gain moyen mais moins performant en moyenne versus

z apprentissage lent, prudent, performant à long terme

z si ε est toujours > 0 on parle de politique ε-soft

Jouer le meilleur « greedy action » max_a(Q(a))

Explorer

ε 1-ε

Explorations plus fines

{ Softmax

z Dépend de Q_t(a_i)

z plus une action est “valable” plus elle a de chance d’être choisie (distribution de Boltzman, fixer la température ?)

τ→0 : greedy

∑

b Q a Q

t t

e e

1

/ ) ( / ) (

τ

probabilité τ

de choisir « a »

parmi n actions τ→∞ : equiprobable

Explorations plus fines

{ Est-ce que l’estimation du gain des actions est pertinente pour fixer la probabilité de choix ?

{ Qu’est ce qu’une bonne action -> référence/aux autres ?

{ Méthode des comparaisons de renforcement

z Dissocier “préférence” et “valeur” d’une action

z la préférence reflète la variation de la différence entre le gain

“moyen” r et celui de l’action concernée

z la probabilité de choix dépend de la préférence

] [

) ( )

1( t t t

t a p a r r

p ₊ = + β −

∑

a p_t

e

Explorations plus fines

{ Méthodes de poursuites

z définition récursive de la probabilité de choix de la

“greedy action a”

z pour les autres actions (b)

z doucement, la probabilité de choix de la meilleure

)]

( 1

[ )

( )

1

( a

a

a

t

π β π

π

= + −

)]

( 0

[ )

( )

1

( b

b

b

t

π β π

π

= + −

Choix d’une méthode

{

Spécifique au problème

{

Explication sur cas simplifiés

z valeur moyenne des renforcements

z différences entre les valeurs moyennes des renforcements

z variance des renforcements

L’apprentissage de π*

{ Apprendre le modèle de l’environnement.

z Quelles récompenses pour chaque état.

z Quels sont les états atteints pour chaque action.

z Problème : supervisé, complexe, interactions entre états ignorées (état qui mène à l’état qui … donne une récompense).

{ Apprendre avec des “fonctions d’utilité”

z La fonction d’utilité est à rapprocher du gain moyen

z Elle est liée à un état ou un couple état-action

z Elle correspond à une espérance de gain futur

Fonction d’utilité V(s) (s->ℜ)

{ V(s) Gains que l’on peut espérer à partir de s

{ V*(s) : valeur optimale (inconnue)

{ V^π(s): valeur pour une stratégie π

z Exemple pour un gain avec intérêt et horizon infini :

{ ^{R s s} }

E s

V

( ) =

=

⎭⎬

⎫

⎩⎨

⎧ =

=

∑

= + + 0

) 1

(

k

t k

t

kr s s

E s

V ^π _π γ

Exemple

{

L ’environnement

Renforcements

- bords : -1 - A->A ’ : 10 - B->B ’ : 5

(pour toute action) - ailleurs : 0

A B

A’

B’

actions ⁺⁵

+10

Exemple V

^{avec π} probabiliste

{ stratégie π : probabilité de choix des 4 directions identique partout π(s_i,droite) = π(s_i,haut) = … = 0.25

{ remise : γ=0.9 V^π

A B

A’

B’

8.8 5.3

1.5

4.4 1.5

3.3

3.0 2.3 1.9 0.5 0.1 0.7 0.7 0.4 -0.4

-1 -0.4 -0.4 -0.6 -1.2 -2 -1.4 -1.2

-1.3 -1.9

+5 +10

Gain et stratégie optimale

{ V* : gains optimums pour la stratégie optimale π*

V* π*

24.4 19.4

19.8

22 ^17.5

22

22 ^{19.8 17.8} 16

17.8 19.8 17.8 16 ^14.4 16 ^17.8 16 ^14.4 13

13 11.7

14.4 16

14.4

+10

+5 +5

+10

Fonction d’utilité Q

{ Comme V mais …

z sur une action : Q(a) : a -> ℜ

z sur un couple état/action : Q(s,a) : (s,a) -> ℜ

z Q(s,a) : gains espérés en exécutant a à partir de s.

{ Q* valeur optimale (inconnue)

{ Q^π(s,a) valeur pour une politique π

z Exemple pour un gain avec intérêt et horizon infini :

⎭⎬

⎫

⎩⎨

⎧ = =

=

∑

= + + 0

1 ,

) , (

k

k t

kr st s at a

E a

s

Q^π _π γ

Chercher π*

{ Hiérarchie entre stratégies

{ La stratégie optimale est supérieure à toute les autres

{ Il en existe toujours une dans les processus Markoviens

s s

V s

V

ssi ≥ ∀

≥ π ' ^π ( ) ^π '( ), π

Processus Markovien

{ Un état suffit à résumer toute l’histoire du système

{ Une décision peut être prise juste en observant cet état

{ Exemple : situation d’un jeu de dame à un instant donné.

Chercher π*

{ Connaissance de la dynamique de l ’environnement :

z pas besoin de simulation.

z programmation dynamique : corrélation entre les états (bootstrap)

{ Sans connaissance de la dynamique de l ’environnement :

z simuler (contrôler) et apprendre

{ sans « bootstrap » : Méthode de Monté-Carlo

{ avec « bootstrap » : Temporal Difference Learning

z identification « off-policy »

{ utiliser une politique différente de celle que l ’on recherche

{ permet de rechercher une politique optimale et « dure »

z identification « on-policy »

{ utiliser la politique que l ’on optimise durant l ’optimisation

Programmation dynamique

{ Connaissance de la dynamique de l ’environnement.

{ MDP (Markov Decision Process),

{ Apprentissage optimal

z équation de Bellman

z V peut être calculé

z V* existe et peut être calculé

z π* existent et peuvent être calculées

a ss'

P

R

par l ’action a Renforcement lors du passage de

s à s’ par a

Programmation dynamique : Principe

π₀ V^π0 π₁ V^π1 π^*

aléatoire

a ss'

P R

E A E

E : évaluation A : amélioration

Utilisation de la corrélation entre états -> bootstrap

V*, Q* et a* formellement

V*(s) est la meilleure utilité trouvée parmis les stratégies

s s

V s

V^*( ) = max ^π ( ),∀

π

Partant de s_t pour une action a menant à s’, le gain espéré est

[

]

t +γ

Corrélation inter-état

a s s_t

P _'

L’action a peut mener à différents états s’ avec une probabilité

a*_t est l’action qui permettra d’obtenir la meilleure utilité

[

]

'

* ArgMax P R V s a_{t s}^a_{s s s}

t

t +γ

=

∑

V*, Q* et a* formellement

Si l’on travaille avec Q

a et

s a

s Q a

s

Q^*( , ) = max ^π ( , ),∀ ∀

π

) , (

* *

a s Q

ArgMax

a _t

a

t =

Evaluation d’une stratégie probabiliste

{

}

E s

V^π ( ) = _{π t t} =

⎭⎬

⎫

⎩⎨

⎧ =

= ^∞ _{+ +}

∑

E _{t k t}

k

k

1 0

π γ

⎭⎬

⎫

⎩⎨

⎧ + =

= ^∞ _{+ +}

+

∑

r

E _{t k t}

k

k

t 2

0

1 γ γ

π

⎥⎦

⎢ ⎤

⎣

⎡

⎭⎬

⎫

⎩⎨

⎧ =

+

= ^∞ _{+ + +}

∑

∑

∑

0 '

'

' R E r s s

P a

s _{t k t}

k

k a

ss

a s

a

ss γ γ

π _π

[

]

) ,

( _'

'

' R V s

P a

s _ss^a

a s

a ss

γ π

π +

=

∑ ∑

V^π(s) peut être calculé à partir d’une estimation de V^π(s’)

Evaluation d’une stratégie probabiliste

{

On peut approximer itérativement V

{

Point fixe :

{

Stratégie déterministe : {

}

E s

V_k+1( ) = _{π t+1} +γ _k( _t+1) _t =

V

V

=

[

]

) , ( )

( _'

' '

1 s s a P R V s

V _ss^a _k

a s

a ss k

γ π

π +

=

∑ ∑

+

La meilleure action : vers une stratégie déterministe

) , ( )

(s ArgMax Q s a

a

π

{

}

E

ArgMax _{t t t t}

a

=

= +

= _{π +1}

γ

[

^{( ' )} ]

'

'

R V s

P

ArgMax

s

a ss a

γ

+

= ∑

Programmation dynamique

Modèle de l ’environnement

a

P

R

)]

' ( [

) , ( )

(

'

s V a

s s

V

a s

π π π = ∑ π ∑^Pss'π^{(s) Rss'(s)} +γ

π_n π₀ aléatoire

itérations

stabilisation : V^π

evaluation de la stratégie

« bootstrap »

amélioration de la stratégie

)]

' ( [

max arg )

(

'

s V

s ^a

s a a

γ π

π = ∑^{Pss' Rss'} +

Programmation dynamique, l ’algo complet (stratégie déterministe)

--- 1.Initialization

V(s) ∈ℜ, π(s) ∈A(s) arbitrairement pour tout s∈S --- 2. Evaluation de la stratégie

Repeat

∆←0For each s∈S

v←V(s) V(s) ←

∆←max(∆,|v-V(s)|) until ∆<θ (a small positive number)

--- 3. Amelioration de la stratégie

policy-stable←true For each s∈S

b← π(s)

π(s) ← arg max_a

)]

' ( [

'

s V

s

γ

π

π +

∑^{Pss'(s) Rss'(s)}

)]

' ( [ ^a V s

a +γ

∑^{Pss' Rss'}

Bootstrapping :

Corrélation entre états

Quand l’environnement est inconnu

{

Différents algorithmes

{

Doivent effectuer 2 fonctions :

z Evaluation (prévision)

{ bootstrap ou moyenne ou les deux

z Contrôle (simulation) en apprenant

{ implémentation réelle

Méthode de Monte-Carlo

{ Plus de connaissance de

{ Estimation de l’espérance de gain par expérience et moyennage

{ Plus de corrélation entre états

z recherche plus lente

a ss'

P R

{

}

E s

V^π ( ) = _{π t t} =

Méthodes de Monte Carlo : off-policy

Choix aléatoire d ’une stratégie π

et de Q.

Jouer l ’épisode π_n

nouveau Q

Contrôle du système évaluation « soft » de la stratégie

(sur un épisode) Q(s,a) = moyenne des

renforcements (par s,a)

π(s) = arg max_a Q(s,a) amélioration de la stratégie

Temporal-Difference ou TD- Learning

{ Prise en compte de la corrélation inter-état de la programmation dynamique = plus rapide

{ Calcul itératif de la fonction d’utilité :

{ V(s) ←V(s)+α[R_t-V(s))]

{ Q_k+1= Q_k+ α[erreur]

{ le calcul partiel des méthodes de MC (moins lourd)

{ naturellement en-ligne

{ pas de preuves de convergence mais fonctionne dans

Evaluer l’utilité itérativement, exemple pour Q

ka r r

a r

Q_t = + +...+ ^ka )

( ^{1 2}

1

1 1 1 =

∑

+ k

Q r

k

i i

k

] [

1 *

Q r

Q

Q = + −

1

1 1

1 +

=

∑

+ k

r Q r

k

i i t

k

Qk

( )

1 1

)

* ) 1 (

* ) 1 (

* ( ) 1 (

*

) (

* 1

* )

1 (

*

* 1 1 1 1

1 + +

+

+

− +

= + + +

= + +

= ⁼ + ^{+ + +}

+

∑

k r k

Q k

Q k

Q k k

k r k k

Q k k

k

r r

k k t k k k t

k

i i t

Qk

1 1

)

* ) 1 (

*

( ₁

1 + +

+ + + −

= ⁺

+ k

r k

Q k

Q Q k

Q_{k k} ^{k k t}

Programmation dynamique -> TD learning

{ Programmation dynamique :

{ TD learning : approximation

{ V(s) ←V(s)+α[r+γV(s’)-V(s)]

{ Idem pour Q ^:

{ Q(s_t,a_t) = Q(s_t,a_t)+α*[r_t+1+γ*Q(s_t+1,a)-Q(s_t,a_t)]

{

}

E s

V_k+1( ) = _{π t+1} +γ _k( _t+1) _t =

Interêt du aux horizon non bornés + Inter-corrélation

Sarsa : On-Policy

Apprentisage de Q(s,a)

Choix aléatoire : Q et s choix de a par Q (soft)

D ’après Q (soft car « on-policy ») appliquer a, observer r et s ’ choisir a’ (d ’après Q et s’)

Q(s,a) = Q(s,a) + α[r+γ Q(s’,a’)-Q(s,a)]

s = s’ ; a = a’

Contrôle du système

Amélioration de la stratégie

Q-learning : off-Policy

Choix aléatoire : Q et s

D ’après Q (rendu « soft» temporairement) choisir a, observer r et s ’

Q(s,a) = Q(s,a) + α[r+γ max_a’Q(s’,a’)-Q(s,a)]

s = s’

Contrôle du système

amélioration de la stratégie

Pas la stratégie

Performance :

Q-learning/Sarsa

{

Très difficile

z Problème dépendant

Actor-Critic Methods On-Policy

Politique

Environnement V

acteur

critique

erreur

correction

δ_t+1 = r_t+1- (V(s_t) - γV(s_t+1)) États

s_t

s_t+1 r_t+1 renforcement

Exemple : softmax (+ou- sur proba action)

renforcement espéré

action

R-Learning

{

Cas particulier de problèmes

z Apprentissage continu (sans fin)

z Mais sans remise (pas de γ)

{

Pas de sommation des remises

{

Prise en compte de la dérivée de

l ’erreur

TD(λ) : aspects temporels et environnements dynamiques

Monté-Carlo TD(0) : sarsa

épisode

Optimisation : Moyenne des r_i

épisode

t₀ t₁ t₂ t₃ t₄ t₀

t₁ t₂

.. Optimisations :

ri + prévision précédente

Rapide/moins précis Lent/précis (si env pas dyn)

TD(λ) : SARSA(λ), Q(λ),

t₀ t₁ t₂ t₃ t

Optimisation sur

tous les r précédents, mais pondération sur les

Q(s,a) les plus récents

instant présent

4

e(t) trace d ’elligibilité d ’un état (ou état-action)

• Sorte de facteur d’oubli

• Deux possibilités : accumulation ou replacement accumulation replacement

e(t)

1

0

SARSA(λ) : l ’algo complet (en cadeau gratuit)

--- Initialize Q(s,a) arbitrarily and e(s,a)=0, for all s,a Repeat (for each episode)

Initialize s,a

Repeat (for each step of episode) Take action a, observe r, s’

Choose a’ from s’ using policy derived from Q (e.g., ε-greedy) δ ← r + γQ(s,a ’) - Q(s,a)

e(s,a) ←e(s,a)+1 For all s, a:

Q(s,a) ← Q(s,a) + α δ e(s,a) e(s,a) ← γλe(s,a)

s ←s’; a ←a’

until s is terminal

Ça c’est intéressant accumulation

Sarsa(λ) sur un labyrinthe

{

Les premiers pas sont utilisés pour évaluer Q

*

* *

Sarsa(λ)

chemin Sarsa

TD( λ)

{ Autres algorithmes

z Q(λ) (2 versions)

z « Elligibility Traces for Actor-Critic Methods »

z Ecrêtage de e (états trop visités)

{ Implémentation

z assez lourde (mémoire+temps)

z heuristiques bidouillantes

z facilement distribuable

Généralisation et approximation

{

Trop de données

z états

z Actions

{

Regrouper

z généraliser

z en apprenant

Généralisation

{

Fonction-Valeur dépend de paramètres

{

{

Bien moins de paramètres que d ’états

{

descente de gradient : en apprentissage :

)

^r θ ( V

[ ]

1 ( ) ( )

2 1

t t t

t

t V s V s

t −

∇

−

+ = π

α θ

θ

θ^{r r r}

Descente de gradient Principe

V^π ou estimation

erreur d(erreur)

dt

Mise à jour θ

F (S, θ⁾ V S

θ

Deux méthodes éprouvées

{

Réseaux de Neurones Artificiels

{

Méthodes linéaires

θ S V

s T s t

s

V ( ) = θ ^r φ ^r

θφ

r

Méthodes linéaires

{

Rapport qualité-prix !!

{

φ : caractéristiques des états

z tache critique

{

exemple coarse coding

z chaque cercle est un φi (taille de θ = nb cercles)

0

1 4

φ₀=1 φ_n=0

S est continu (2D)

Méthodes linéaires

{

Tile coding (carrelage)

{

Radial Basis Functions

z φ n ’est pas binaire

z méthode de structuration

carrés

logarithmes ...

⎟ ⎞

⎜ ⎛ −

=

2

exp )

( s ci

φ i

Méthodes linéaires

{

La voiture

x x

10 grilles décalées

Goal

Actions : accélèration avant(1), arrière(-1), nulle(0) x =bound[x +x ]

Résultats apprentissage et généralisation

{

Par replacement d’éligibilité

800 λ=1

λ=0.99

λ=0 λ=0.9

λ=0.4

400

α

Pour en savoir plus : en annexe

{

Karneva coding

{

apprentissage de planification

{

Dyna-Q algorithme

{

Prioritized Sweeping

z Manœuvres dans un labyrinthe

{ 14 400 états potentiels * 4 actions

{ pas tous scrutés bêtement

Les problèmes à résoudre

{

Nb couples état-action

{

Convergence

{

Hiérarchisation des actions

{

Sémantisation des actions

¾

Systèmes de classifieurs (C.Buche).

Bibliographie

{ Thorndike, Animal Intelligence, 1911.

{ Bellman, Dynamic Programming, 1957.

{ Richard S.Sutton and Andrew G.Barto, Reinforcement Learning, MIT Press, 2000.

{ Cédric Sanza, Evolution d ’entités virtuelles

cooperatives par système de classifieurs. These de doctorat de l ’université de Toulouse, 2001.

{ Apprentissage automatique et évolution artificielle, revue extraction des connaissances et apprentissage, Volume1, n°3, éditions hermes, 2001.

{ Algorithmes d ’apprentissages et applications, revue d ’intelligence artificielle, volume 14, n°3, édition hermes, 2000.

{ Antoine Cornuéjols et Laurent Miclet, Apprentissage artificiel, concepts et algorithmes, éditions Eyrolles, 2002.

Annexes

Rappels

{

Approche supervisée : retour instructif, indique la bonne solution.

{

Renforcement : retour évaluatif, on ne sait pas quelle est la bonne

{

Il faut une exploration “active”

{

Plein de stratégies : exemple de la

machine à sous à n bras

Apprentissage supervisé

Modèle à paramétrer RdN,

entrées résultat

entrées résultat

Algorithme d’apprentissage

paramètres

Sarsa : estimation des Q(s,a) On- Policy TD

{

On évaluent tous les Q (s,a)

pendant la simulation, on en déduit

une politique en même temps...

Avantage de Sarsa sur MC

{

Si il y a une impasse sarsa diminue le Q(s,a) qui ne sera bientôt plus

choisi car sarsa apprend pendant l ’épisode

{

MC resterait dans l ’impasse

{

exemple 6.4 de Reinforcement

learning An introduction (Sutton

2000)

Propriété markovienne

{

Distribution de proba de s

et r

{ Pr{s_t+1 = s’, r_t+1=r | s_t,a_t,r_t, s_t-1,…r₁,s₀,a₀} (1)

{ Si elle ne dépend que de l’instant présent

{ Pr{s_t+1 = s’, r_t+1=r | s_t,a_t} (2)

{ les états ont une propriété markovienne si (1) = (2)

{ ?

Programmation dynamique

{

Optimisations

z algorithme d ’itération des valeurs

{ calcul de V_k+1(s) (et non d ’évaluation des politiques)

{ puis une seule opération pour obtenir la politique optimale

z Programmation dynamique asynchrone

{ pour les gros espaces d ’état

{ on ne calcul V_k+1(s) que pour un état à chaque fois

Programmation Dynamique

{ Calculs coûteux (mémoire/temps)

{ Dynamique de l ’environnement

{ Généralisation aux politiques probabilistes choix de plusieurs actions par état défini par π(s,a)

{ Temps polynomial (n états et m actions)

z alors qu ’il y a mⁿ solutions potentielles

Méthode de Monte-Carlo: l ’algo complet

--- 1.Initialization

for all s∈S, a∈A(s) :

Q(s,a) ←arbitraire

Returns(s,a) ← liste vide

π ← une politique arbitraire ε-soft policy --- 2. Evaluation de la politique

Repeat forever

(a) Generate an episode using π

(b) for each pair s,a appearing in the episode:

R ←return following the first occurrence of s,a Append R to Returns(s,a)

Q(s,a) ← average(Returns(s,a)) (c) for each s in the episode:

a* ← arg max_a Q(s,a) For all a ∈A(s) :

1-ε+ ε/|A(s)| if a=a*

Principe des algorithmes de type TD-learning

{

Estimation d ’une politique V

:

--- 1.Initialisation : V(s) arbitraire, π poitique à évaluer Repeat(for each episode) :

Initialize s

Repeat(for each step of episode):

a← action given by π for s

Take action a; observe reward r and next state s’

V(s) ←V(s)+α[r+γV(s’)-V(s)]

s ←s’

until s is terminal

Annexe : Définition récursive de Q(a)

ka r r

a r

Q_t = + +...+ ^ka )

( ^{1 2}

1

1 1 1 =

∑

+ k

Q r

k

i i

k

] [

1 *

Q r

Q

Q = + −

1

1 1

1 +

=

∑

+ k

r Q r

k

i i t

k

Qk

( )

1 1

)

* ) 1 (

* ) 1 (

* ( ) 1 (

*

) (

* 1

* )

1 (

*

* 1 1 1 1

1 + +

+

+

− +

= + + +

= + +

= ⁼ + ^{+ + +}

+

∑

k r k

Q k

Q k

Q k k

k r k k

Q k k

k

r r

k k t k k k t

k

i i t

Qk

1 1

)

* ) 1 (

*

( ₁

1 + +

+ + + −

= ⁺

+ k

r k

Q k

Q Q k

Q_{k k} ^{k k t}

Méthodes linéaires

{

complexité≈

{

Kanerva coding

z séparation dimension de S/complexité de V

z plus de dimension : codage binaire des états

z distance de hamming pour les regroupements

z travaux en cours

e

Apprentissage et Généralisation

{

Etudes expérimentales : algo de type Sarsa et Q-learning plus

stables

z Linear gradient-descent Sarsa(λ)

z Linear gradient-descent Q(λ)

{

RDN : à voir, il me semble que

c ’est très chaud de faire bosser en

parallèle deux algos comme ça.

Planification et apprentissage

{

Planifier

z i.a. classique : modèle + cognition

z ici : améliorer Q (ou V) par

l ’évaluation d ’un modèle + simulation du modèle

V, politique

experience model

planification action

RL

Modèle déterministe

{

Pour un couple (s,a) donné le

renforcement est toujours le même

z Labyrinthe

{

Dyna-Q algorithme

Q-learning Q

Model-learning ^{Modèle env}₌ Simulation

aléatoire

parmi les situations mémorisées

Q-learning ’

Modèle en évolution

{

heuristique de Dyna-Q+

z si un couple(s,a) n ’a pas été rencontré depuis longtemps, lui attribuer un

renforcement espéré + grand pour obliger le système à explorer