Temporal Difference Learning

Transkript

1 Temporal Difference Learning Das Temporal Difference (TD) Lernen ist eine bedeutende Entwicklung im Reinforcement Lernen. Im TD Lernen werden Ideen der Monte Carlo (MC) und dynamische Programmierung (DP) Methoden kombiniert. Im TD Lernen wird wie beim MC Lernen aus Erfahrung ohne Kenntniss eines Modells gelernt, d.h. dieses wird aus Daten/Beispielen gelernt. Wie beim DP werden Schätzungen für Funktionswerte durchgeführt (V π (s) oder Q π (s, a)), die wiederum auf Schätzungen basieren (nämlich die Schätzungen V π (s ) nachfolgender Zustände). Wir beginnen mit der Evaluation von Policies π, d.h. mit der Berechnung der Wertefunktionen V π bzw. Q π. F. Schwenker Reinforcement Learning 85

2 TD Evaluation TD und MC Methoden nutzen Erfahrung aus Beispiele um V π bzw. Q π für eine Policy π zu lernen. Ist s t der Zustand zur Zeit t in einer Episode, dann basiert die Schätzung von V (s t ) auf den beobachteten Return R t nach Besuch des Zustand s t In MC Methoden wird nun der Return R t bis zum Ende der Episode bestimmt und dieser Schätzwert für V (s t ) angesetzt. Eine einfache Lernregel nach der Every Visit MC Methode hat dann die folgende Gestalt: V (s t ) := V (s t ) + α [R t V (s t )] mit α > 0 In den einfachen 1-Schritt TD Methoden nur der nächste Zustandsübergang s s abgewartet und der unmittelbar erzielte Reward zusammen mit V (s ) benutzt. F. Schwenker Reinforcement Learning 86

3 Ein 1-Schritt TD Algorithmus, der sog. TD(0) Algorithmushat die Lernregel V (s t ) := V (s t ) + α [r t+1 + γv (s t+1 ) V (s t )] α > 0, γ (0, 1] Zur Erinnerung es gilt V π (s) = { E π Rt s t = s } = { E π γ k r t+1+k s t = s } k=0 = E π {r t+1 + γ } γ k r t+2+k s t = s k=0 = E π {r t+1 + γv π (s t+1 ) s t = s} Sollwert beim MC Lernen : R t Sollwert beim TD Lernen : r t+1 + γv π (s t+1 ) F. Schwenker Reinforcement Learning 87

4 TD(0) Schätzung von V π 1. Initalize V (s) arbitrarily, π policy to be evaluated 2. Repeat (for each episode) TD-Backup Diagramm Initialize s Repeat (for each step of episode): a := π(s) take a, observe reward r, and next state s V (s) := V (s) + α [ r + γv (s ) V (s) ] s := s s, s S sind die offenen Kreise a A die Aktion π(s) gefüllter Kreis Until s is terminal F. Schwenker Reinforcement Learning 88

5 Sarsa Ziel ist das Erlernen der Q-Funktion statt der V -Funktion durch On Policy Methode, d.h. Schätzung der Werte Q π (s, a) für die verwendete Policy pi. Es kann dasselbe Verfahren wie zur Schätzung der V -Funktion verwendet werden mit der Lernregel Q(s t, a t ) := Q(s t, a t ) + α [r + γq(s t+1, a t+1 ) Q(s t, a t )] Hierzu betrachten wir Zustandsübergänge: r t+1 st s t+1 r t+2 s t+1,a t+1 s t,a t s t+2 s t+2,a t+2 F. Schwenker Reinforcement Learning 89

6 Sarsa: Algorithmus 1. Initalize Q(s, a) arbitrarily, 2. Repeat (for each episode) Initialize s Choose a from s using policy derived from Q (e.g. ɛ-greedy) Repeat (for each step of episode): Take a, observe reward r, and next state s Choose a from s using policy derived from Q (e.g. ɛ-greedy) Q(s, a) := Q(s, a) + α [ r + γq(s, a ) Q(s, a) ] s := s ; a := a Until s is terminal F. Schwenker Reinforcement Learning 90

7 Q-Learning Q-Lernen ist das wichtigste Verfahren im Bereich des Reinforcement Lernens, es wurde von Watkins 1989 entwickelt. Ist ein Off Policy TD Lernverfahren definiert durch die Lernregel Q(s t, a t ) := Q(s t, a t ) + α [ ] r + γ max Q(s t+1, a Q(s t, a t ) a Q konvergiert direkt gegen Q (vereinfacht die Analyse des Verfahrens). Policy π legt die Aktion fest, und somit wird durch π die Folge von (s t, a t ) festgelegt, die in der Episode vorkommen (und damit auch die Stellen an den die Q-Funktion gelernt wird). F. Schwenker Reinforcement Learning 91

8 1. Initalize Q(s, a) arbitrarily, Q-Learning: Algorithmus 2. Repeat (for each episode) Q-Learning Backup Initialize s Repeat (for each step of episode): Choose a from s using policy derived from Q (e.g. ɛ-greedy) Take a, observe reward r, and s a := arg max a Q(s, a) Q(s, a) := Q(s, a) + α [ r + γq(s, a ) Q(s, a) ] s := s ; s, s S sind die offenen Kreise a, A die Aktion π(s) gefüllte Kreise max durch Kreisboden Until s is terminal F. Schwenker Reinforcement Learning 92

9 TD n-step Methoden Die bisher vorgestellten TD Lernverfahren verwenden den unmittelbar folgenden Reward (k = 1-Schritt) r t+1. Idee bei den Mehrschritt Methoden ist es, auch die nächsten k = 2, 3,... n erzielten Rewards r t+k einzubeziehen. Dazu betrachten wir die Zustands-Reward-Folge s t, r t+1, s t+1, r t+2,..., r T, s T s T der Endzustand. MC Methoden verwenden zum Backup von V π (s t ) den Return R t = r t+1 + γr t+2 + γ 2 r t γ T t 1 r T R t ist das Lehrersignal (Sollwert) für die MC Lernverfahren. F. Schwenker Reinforcement Learning 93

10 Für 1-Schritt TD Methoden ist das Lehrersignal R (1) t = r t+1 + γv t (s t+1 ) hier dient γv t (s t+1 ) als Näherung für γr t+2 + γ 2 r t γ T t 1 r T Bei einem 2-Schritt-TD Verfahren ist der Sollwert R (2) t = r t+1 + γr t+2 + γ 2 V t (s t+2 ) wobei jetzt γ 2 V t (s t+2 ) die Näherung ist für γ 2 r t+3 + γ 3 r t γ T t 1 r T Allgemein ist der n-schritt-return R (n) t zur Zeit t gegeben durch R (n) t = r t+1 + γr t+2 + γ 2 r t+3 + γ n 1 r t+n + γ n V t (s t+n ) F. Schwenker Reinforcement Learning 94

11 Lernregel für die V-Funktion mit n Schritt Backups ist also [ ] V t (s t ) = α R (n) t V t (s t ) TD (1-step) 2-step 3-step n-step Monte Carlo F. Schwenker Reinforcement Learning 95

12 TD(λ)-Verfahren Backups können nicht nur auf der Basis von n-schritt Returns R (n) t, sondern durch Mittelung verschiedener n-schritt Returns erfolgen, z.b. Mittelwert eines 2 und 4 Schritt Returns R ave t = 1 2 R(2) t R(4) Allgemeine Mittelungen sind möglich. Nur die Gewichte sollten nichtnegativ sein und sich zu 1 summieren. Dies führt auf die T D(λ) Verfahren, hier werden alle n-schritt Returns gewichtet. 1 2 Mit einem Nomalisierungsfaktor 1 λ (stellt sicher das die Summe der Gewichte = 1 ist) definieren wir den λ-return durch R λ t = (1 λ) n=1 T t 1 λ n 1 R (n) t = (1 λ) n=1 λ n 1 R (n) t + λ T t 1 R t 1 2 F. Schwenker Reinforcement Learning 96

13 TD(λ)-Backup-Diagramm TD(λ), λ-return 1 λ (1 λ) λ (1 λ) λ 2 Σ = 1 λ T-t-1 F. Schwenker Reinforcement Learning 97

14 Gewichtung von λ Update (hier der V -Funktion) bei einem λ-return Algorithmus V t (s t ) = α [ R λ t V t (s t ) ] weight given to the 3-step return total area = 1 Weight 1 λ decay by λ weight given to actual, final return t Time T F. Schwenker Reinforcement Learning 98

15 Forward View/Backward View r T r t+1 r t+2 s t+1 s t+2 r t+3 s t+3 s t Time Forward View: Ist nicht kausal und kann deshalb auch nicht so direkt implementiert werden. e t e t e t δt s t-3 s t-2 s t-1 e t s t s t+1 Time F. Schwenker Reinforcement Learning 99

16 Kummulative Trace-Variable Backward View benötigt für jeden Zustand eine Trace-Variable e t (s) die definiert ist als { γλe t 1 (s) s s t e t (s) = γλe t 1 (s) + 1 s = s t Dabei zeigt e t (s) > 0 an, dass der Zustand s kürzlich besucht wurde. Kürzlich ist hierbei durch die Größe γλ definiert. e t (s) zeigt, für welche Zustände s S die Funktion V bzw. Q anzupassen ist. accumulating eligibility trace times of visits to a state F. Schwenker Reinforcement Learning 100

17 Die Fehlersignale sind (hier für V -Funktion): δ t = r t+1 + γv t (s t+1 ) V t (s t ) Alle kürzlich besuchten Zustände s werden damit adaptiert (wieder für V ) V t (s t ) = αδ t e t (s) für alle s S Hierbei ist wieder γ (0, 1] der Diskontierungsfaktor und α > 0 eine konstante Lernrate. F. Schwenker Reinforcement Learning 101

18 TD(λ) 1. Initalize V (s) arbitrarily and e(s) = 0; π policy to be evaluated 2. Repeat (for each episode) Initialize s Repeat (for each step of episode): a := π(s) take a, observe reward r, and next state s δ := r + γv (s ) V (s) e(s) := e(s) + 1; For all s: V (s) := V (s) + αδe(s) e(s) := γλe(s) s := s Until s is terminal F. Schwenker Reinforcement Learning 102

19 Äquivalenz der beiden Methoden Wir zeigen nun, das die Updates von V der Vorwärts- und Rückwärtssicht für das Off-line-Lernen äquivalent sind. Es sei V λ t (s t ) die Änderung von V (s t ) zur Zeit t nach der λ-return Methode (Vorwärtssicht). Es sei Vt T D (s) die Änderung von V (s) zur Zeit t von Zustand s nach dem TD(0) Algorithmus (Rückwärtssicht). Ziel ist es also zu zeigen T 1 t=0 V λ t (s t )1 [s=st ] = T 1 t=0 V T D t (s) für alle s S F. Schwenker Reinforcement Learning 103

20 es ist 1 [s=st ] gleich 1 genau dann wenn s = s t ist. Wir untersuchen einen einzelnen Update V λ t (s t ) = α [ R λ t V t (s t ) ]. 1 α V λ t (s t ) = V t (s t ) + (1 λ)λ 0 [r t+1 + γv t (s t+1 )] + (1 λ)λ 1 [ r t+1 + γr t+2 + γ 2 V t (s t+2 ) ] + (1 λ)λ 2 [ r t+1 + γr t+2 + γ 2 r t+3 + γ 3 V t (s t+3 ) ] + (1 λ)λ 2 [ r t+1 + γr t+2 + γ 2 r t+3 + γ 3 r t+4 + γ 4 V t (s t+4 ) ] Summation spaltenweise nach den Rewards r t+k durchführen, dh. zuerst die r t+1 mit den Gewichten (1 λ)λ k über k = 0, 1,... summieren ergibt den Wert 1 (geometrische Reihe), dann r t+2 mit den Gewichten (1 λ)γλ k über k = 1, 2, 3,... ergibt den Wert γλ, usw. mit r t+k für k 3, 4,.... F. Schwenker Reinforcement Learning 104

21 1 α V λ t (s t ) = V t (s t ) + (γλ) 0 [r t+1 + (1 λ) γv t (s t+1 )] + (γλ) 1 [r t+2 + (1 λ) γv t (s t+2 )] + (γλ) 2 [r t+3 + (1 λ) γv t (s t+3 )] + (γλ) 3 [r t+4 + (1 λ) γv t (s t+4 )] = (γλ) 0 [r t+1 + γv t (s t+1 ) V t (s t )] + = (γλ) 1 [r t+2 + γv t (s t+2 ) V t (s t+1 )] + (γλ) 2 [r t+3 + γv t (s t+3 ) V t (s t+2 )] + (γλ) 3 [r t+4 + γv t (s t+4 ) V t (s t+3 )] (γλ) k t δ k = k=t T 1 k=t (γλ) k t δ k F. Schwenker Reinforcement Learning 105

22 Wir können somit für die Summe der Updates durch λ-return schreiben: ( T 1 T 1 T 1 ) Vt T D (s)1 [s=st ] = α (γλ) k t δ k 1 [s=st ] t=0 = α t=0 T 1 t=0 k=t 1 [s=st ] T 1 k=t (γλ) k t δ k. F. Schwenker Reinforcement Learning 106

23 Nun die Updates des TD(0) Verfahrens: Zunächst gilt e t (s) = t (γλ) t k 1 [s=sk ] k=0 Einsetzen liefert nun T 1 t=0 V T D t (s) = = α = α = α T 1 t=0 T 1 k=0 T 1 t=0 T 1 t=0 αδ t t (γλ) t k 1 [s=sk ] k=0 k (γλ) k t 1 [s=st ]δ k t=0 T 1 k=t 1 [s=st ] (γλ) k t 1 [s=st ]δ k T 1 k=t (γλ) k t δ k F. Schwenker Reinforcement Learning 107

24 Sarsa(λ) Idee von Sarsa(λ) ist, den Sarsa-Algorithmus zum Erlernen der Q- Funktion mit der TD(λ) Methoden zu kombinieren. Statt der Variablen e t (s) für alle s S brauchen wir Variablen e t (s, a) für alle (s, a) S A. Dann ersetzen wir V (s) durch Q(s, a) und e t (s) durch e t (s, a). Also Q t+1 (s, a) = Q t (s, a) + αδ t e t (s, a) für alle s S, a A δ t = r t+1 + γq t (s t+1, a t+1 ) Q t (s t, a t ) und e t (s, a) = { γλe t 1 (s) + 1 γλe t 1 (s) falls s t = s und a t = a sonst F. Schwenker Reinforcement Learning 108

25 Sarsa Backup Diagramm Sarsa(λ) s, a t t 1 λ (1 λ) λ (1 λ) λ 2 Σ = 1 λ T-t-1 s T F. Schwenker Reinforcement Learning 109

26 Sarsa Algorithmus (Q als Tabelle) 1. Initalize Q(s, a) arbitrarily and e(s, a) = 0 all s, a 2. Repeat (for each episode) Initialize s, a Repeat (for each step of episode): Take a, observe reward r, and next state 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 F. Schwenker Reinforcement Learning 110

27 Q(λ)-Lernverfahren Es gibt 2 Varianten: Watkin s Q(λ) und Peng s Q(λ) Verfahren (Letzterer ist schwerer implementierbar, deshalb hier nur Watkin s Q-Lernverfahren). Q-Lernen ist ein Off-Policy Verfahren. Beim Q-Lernen folgt der Agent einer explorativen Policy (z.b. ɛ-greedy Verfahren bzgl. der Q-Funktion) und adaptiert die Q-Funktion nach der Greedy-Policy (bzgl. der Q-Funktion). Hier muss in Betracht gezogen werden, dass der Agent explorative Aktionen durchführt, die keine Greedy Aktionen sind. Zum Erlernen der zur Greedy Policy gehörenden Q-Funktionen dürfen diese explorativen Aktionen nicht berücksichtigt werden. Deshalb werden die n-step Returns beim Q(λ) Verfahren auch nur bis zum Auftreten der nächsten explorativen Aktion berücksichtigt, und nicht stets bis zum Ende einer Episode. F. Schwenker Reinforcement Learning 111

28 Q(λ) Backup-Diagramm (Watkins) Watkins's Q(λ) s, a t t 1 λ (1 λ) λ OR (1 λ) λ 2 λ T-t-1 λ n 1 s t+n first non-greedy action F. Schwenker Reinforcement Learning 112

29 Q(λ)-Algorithmus (Q als Tabelle) 1. Initalize Q(s, a) arbitrarily and e(s, a) = 0 all s, a 2. Repeat (for each episode) Initialize s, a Repeat (for each step of episode): Take a, observe reward r, and next state s Choose a from s using policy derived from Q (e.g. ɛ-greedy) a := arg max b Q(s, b) (if a ties for the max, then a := a ). δ := 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) if a = a then e(s, a) := λγe(s, a) else e(s, a) := 0 s := s ; a := a Until s is terminal F. Schwenker Reinforcement Learning 113