Reinforcement Learning An Introduction - Richard S. Sutton , Andrew G. Barto

551 Pages·2004·3.59 MB·English

Reinforcement
Learning:
An Introduction
Richard S. Sutton
and Andrew G. Barto
MIT Press, Cambridge, MA,
1998
A Bradford Book
Endorsements Code Solutions Figures
Errata Course Slides
This introductory textbook on reinforcement learning is targeted toward engineers and
scientists in artificial intelligence, operations research, neural networks, and control
systems, and we hope it will also be of interest to psychologists and neuroscientists.
If you would like to order a copy of the book, or if you are qualified instructor and would
like to see an examination copy, please see the MIT Press home page for this book. Or you
might be interested in the reviews at amazon.com. There is also a Japanese translation
available.
The table of contents of the book is given below, with associated HTML. The HTML
version has a number of presentation problems, and its text is slightly different from the
real book, but it may be useful for some purposes.
Preface
l
Part I: The Problem
1 Introduction
l
1.1 Reinforcement Learning
m
1.2 Examples
m
1.3 Elements of Reinforcement Learning
m
1.4 An Extended Example: Tic-Tac-Toe
m
1.5 Summary
m
1.6 History of Reinforcement Learning
m
1.7 Bibliographical Remarks
m
2 Evaluative Feedback
l
2.1 An n-armed Bandit Problem
m
2.2 Action-Value Methods
m
2.3 Softmax Action Selection
m
2.4 Evaluation versus Instruction
m
2.5 Incremental Implementation
m
2.6 Tracking a Nonstationary Problem
m
2.7 Optimistic Initial Values
m
2.8 Reinforcement Comparison
m
2.9 Pursuit Methods
m
2.10 Associative Search
m
2.11 Conclusion
m
2.12 Bibliographical and Historical Remarks
m
3 The Reinforcement Learning Problem
l
3.1 The Agent-Environment Interface
m
3.2 Goals and Rewards
m
3.3 Returns
m
3.4 A Unified Notation for Episodic and Continual Tasks
m
3.5 The Markov Property
m
3.6 Markov Decision Processes
m
3.7 Value Functions
m
3.8 Optimal Value Functions
m
3.9 Optimality and Approximation
m
3.10 Summary
m
3.11 Bibliographical and Historical Remarks
m
Part II: Elementary Methods
4 Dynamic Programming
l
4.1 Policy Evaluation
m
4.2 Policy Improvement
m
4.3 Policy Iteration
m
4.4 Value Iteration
m
4.5 Asynchronous Dynamic Programming
m
4.6 Generalized Policy Iteration
m
4.7 Efficiency of Dynamic Programming
m
4.8 Summary
m
4.9 Historical and Bibliographical Remarks
m
5 Monte Carlo Methods
l
5.1 Monte Carlo Policy Evaluation
m
5.2 Monte Carlo Estimation of Action Values
m
5.3 Monte Carlo Control
m
5.4 On-Policy Monte Carlo Control
m
5.5 Evaluating One Policy While Following Another
m
5.6 Off-Policy Monte Carlo Control
m
5.7 Incremental Implementation
m
5.8 Summary
m
5.9 Historical and Bibliographical Remarks
m
6 Temporal Difference Learning
l
6.1 TD Prediction
m
6.2 Advantages of TD Prediction Methods
m
6.3 Optimality of TD(0)
m
6.4 Sarsa: On-Policy TD Control
m
6.5 Q-learning: Off-Policy TD Control
m
6.6 Actor-Critic Methods (*)
m
6.7 R-Learning for Undiscounted Continual Tasks (*)
m
6.8 Games, After States, and other Special Cases
m
6.9 Conclusions
m
6.10 Historical and Bibliographical Remarks
m
Part III: A Unified View
7 Eligibility Traces
l
7.1 n-step TD Prediction
m
7.2 The Forward View of TD()
m
7.3 The Backward View of TD()
m
7.4 Equivalence of the Forward and Backward Views
m
7.5 Sarsa()
m
7.6 Q()
m
7.7 Eligibility Traces for Actor-Critic Methods (*)
m
7.8 Replacing Traces
m
7.9 Implementation Issues
m
7.10 Variable (*)
m
7.11 Conclusions
m
7.12 Bibliographical and Historical Remarks
m
8 Generalization and Function Approximation
l
8.1 Value Prediction with Function Approximation
m
8.2 Gradient-Descent Methods
m
8.3 Linear Methods
m
8.3.1 Coarse Coding
n
8.3.2 Tile Coding
n
8.3.3 Radial Basis Functions
n
8.3.4 Kanerva Coding
n
8.4 Control with Function Approximation
m
8.5 Off-Policy Bootstrapping
m
8.6 Should We Bootstrap?
m
8.7 Summary
m
8.8 Bibliographical and Historical Remarks
m
9 Planning and Learning
l
9.1 Models and Planning
m
9.2 Integrating Planning, Acting, and Learning
m
9.3 When the Model is Wrong
m
9.4 Prioritized Sweeping
m
9.5 Full vs. Sample Backups
m
9.6 Trajectory Sampling
m
9.7 Heuristic Search
m
9.8 Summary
m
9.9 Historical and Bibliographical Remarks
m
10 Dimensions
l
10.1 The Unified View
m
10.2 Other Frontier Dimensions
m
11 Case Studies
l
11.1 TD-Gammon
m
11.2 Samuel's Checkers Player
m
11.3 The Acrobot
m
11.4 Elevator Dispatching
m
11.5 Dynamic Channel Allocation
m
11.6 Job-Shop Scheduling
m
References
l
Summary of Notation
l
Endorsements for:
Reinforcement Learning: An Introduction
by Richard S. Sutton and Andrew G. Barto
"This is a highly intuitive and accessible introduction to the recent major developments in
reinforcement learning, written by two of the field's pioneering contributors"
Dimitri P. Bertsekas and John N. Tsitsiklis, Professors, Department of Electrical
Enginneering and Computer Science, Massachusetts Institute of Technology
"This book not only provides an introduction to learning theory but also serves as a
tremendous sourve of ideas for further development and applications in the real world"
Toshio Fukuda, Nagoya University, Japan; President, IEEE Robotics and
Automation Society
"Reinforcement learning has always been important in the understanding of the driving
forces behind biological systems, but in the past two decades it has become increasingly
important, owing to the development of mathematical algorithms. Barto and Sutton were
the prime movers in leading the development of these algorithms and have described them
with wonderful clarity in this new text. I predict it will be the standard text."
Dana Ballard, Professor of Computer Science, University of Rochester
"The widely acclaimed work of Sutton and Barto on reinforcement learning applies some
essentials of animal learning, in clever ways, to artificial learning systems. This is a very
readable and comprehensive account of the background, algorithms, applications, and
future directions of this pioneering and far-reaching work."
Wolfram Schultz, University of Fribourg, Switzerland
Code for:
Reinforcement Learning: An Introduction
by Richard S. Sutton and Andrew G. Barto
Below are links to a variety of software related to examples and exercises in the book,
organized by chapters (some files appear in multiple places). See particularly the
Mountain Car code. Most of the rest of the code is written in Common Lisp and requires
utility routines available here. For the graphics, you will need the the packages for G and
in some cases my graphing tool. Even if you can not run this code, it still may clarify some
of the details of the experiments. However, there is no guarantee that the examples in the
book were run using exactly the software given. This code also has not been extensively
tested or documented and is being made available "as is". If you have corrections,
extensions, additions or improvements of any kind, please send them to me at
[email protected] for inclusion here.
Chapter 1: Introduction
l
Tic-Tac-Toe Example (Lisp). In C.
m
Chapter 2: Evaluative Feedback
l
10-armed Testbed Example, Figure 2.1 (Lisp)
m
Testbed with Softmax Action Selection, Exercise 2.2 (Lisp)
m
Bandits A and B, Figure 2.3 (Lisp)
m
Testbed with Constant Alpha, cf. Exercise 2.7 (Lisp)
m
Optimistic Initial Values Example, Figure 2.4 (Lisp)
m
Code Pertaining to Reinforcement Comparison: File1, File2, File3 (Lisp)
m
Pursuit Methods Example, Figure 2.6 (Lisp)
m
Chapter 3: The Reinforcement Learning Problem
l
Pole-Balancing Example, Figure 3.2 (C)
m
Gridworld Example 3.8, Code for Figures 3.5 and 3.8 (Lisp)
m
Chapter 4: Dynamic Programming
l
Policy Evaluation, Gridworld Example 4.1, Figure 4.2 (Lisp)
m
Policy Iteration, Jack's Car Rental Example, Figure 4.4 (Lisp)
m
Value Iteration, Gambler's Problem Example, Figure 4.6 (Lisp)
m
Chapter 5: Monte Carlo Methods
l
Monte Carlo Policy Evaluation, Blackjack Example 5.1, Figure 5.2 (Lisp)
m
Monte Carlo ES, Blackjack Example 5.3, Figure 5.5 (Lisp)
m
Chapter 6: Temporal-Difference Learning
l
TD Prediction in Random Walk, Example 6.2, Figures 6.5 and 6.6 (Lisp)
m
TD Prediction in Random Walk with Batch Training, Example 6.3, Figure
m
6.8 (Lisp)
TD Prediction in Random Walk (MatLab by Jim Stone)
m
R-learning on Access-Control Queuing Task, Example 6.7, Figure 6.17
m
(Lisp), (C version)
Chapter 7: Eligibility Traces
l
N-step TD on the Random Walk, Example 7.1, Figure 7.2: online and
m
offline (Lisp). In C.
lambda-return Algorithm on the Random Walk, Example 7.2, Figure 7.6
m
(Lisp)
Online TD(lambda) on the Random Walk, Example 7.3, Figure 7.9 (Lisp)
m
Chapter 8: Generalization and Function Approximation
l
Coarseness of Coarse Coding, Example 8.1, Figure 8.4 (Lisp)
m
Tile Coding, a.k.a. CMACs
m
Linear Sarsa(lambda) on the Mountain-Car, a la Example 8.2
m
Baird's Counterexample, Example 8.3, Figures 8.12 and 8.13 (Lisp)
m
Chapter 9: Planning and Learning
l
Trajectory Sampling Experiment, Figure 9.14 (Lisp)
m
Chapter 10: Dimensions of Reinforcement Learning
l
Chapter 11: Case Studies
l
Acrobot (Lisp, environment only)
m
Java Demo of RL Dynamic Channel Assignment
m
For other RL software see the Reinforcement Learning Repository at Michigan State
University and here.
;-*- Mode: Lisp; Package: (rss-utilities :use (common-lisp ccl) :nicknames (:ut)) -*-
(defpackage :rss-utilities
(:use :common-lisp :ccl)
(:nicknames :ut))
(in-package :ut)
(defun center-view (view)
"Centers the view in its container, or on the screen if it has no container;
reduces view-size if needed to fit on screen."
(let* ((container (view-container view))
(max-v (if container
(point-v (view-size container))
(- *screen-height* *menubar-bottom*)))
(max-h (if container
(point-h (view-size container))
*screen-width*))
(v-size (min max-v (point-v (view-size view))))
(h-size (min max-h (point-h (view-size view)))))
(set-view-size view h-size v-size)
(set-view-position view
(/ (- max-h h-size) 2)
(+ *menubar-bottom* (/ (- max-v v-size) 2)))))
(export 'center-view)

(defmacro square (x)
`(if (> (abs ,x) 1e10) 1e20 (* ,x ,x)))
(export 'square)
(defun with-probability (p &optional (state *random-state*))
(> p (random 1.0 state)))
(export 'with-probability)
(defun with-prob (p x y &optional (random-state *random-state*))
(if (< (random 1.0 random-state) p)
x
y))
(export 'with-prob)
(defun random-exponential (tau &optional (state *random-state*))
(- (* tau
(log (- 1
(random 1.0 state))))))
(export 'random-exponential)
(defun random-normal (&optional (random-state cl::*random-state*))
(do ((u 0.0)
(v 0.0))
((progn
(setq u (random 1.0 random-state) ; U is bounded (0 1)
v (* 2.0 (sqrt 2.0) (exp -0.5) ; V is bounded (-MAX MAX)
(- (random 1.0 random-state) 0.5)))
(<= (* v v) (* -4.0 u u (log u)))) ; < should be <=
(/ v u))
(declare (float u v))))
(export 'random-normal)
;stats
(defun mean (l)
(float
(/ (loop for i in l sum i)
(length l))))
(export 'mean)
(defun mse (target values)
(mean (loop for v in values collect (square (- v target)))))
(export 'mse)
(defun rmse (target values) ;root mean square error
(sqrt (mse target values))) (export 'rmse)
(export 'rmse)
(defun stdev (l)
(rmse (mean l) l))
(export 'stdev)
(defun stats (list)
(list (mean list) (stdev list)))
(export 'stats)
(defun multi-stats (list-of-lists)
(loop for list in (reorder-list-of-lists list-of-lists)
collect (stats list)))
(export 'multi-stats)
(defun multi-mean (list-of-lists)
(loop for list in (reorder-list-of-lists list-of-lists)
collect (mean list)))
(export 'multi-mean)
(defun logistic (s)
(/ 1.0 (+ 1.0 (exp (max -20 (min 20 (- s)))))))
(export 'logistic)
(defun reorder-list-of-lists (list-of-lists)
(loop for n from 0 below (length (first list-of-lists))
collect (loop for list in list-of-lists collect (nth n list))))
(export 'reorder-list-of-lists)
(defun flatten (list)
(if (null list)
(list)
(if (atom (car list))
(cons (car list) (flatten (cdr list)))
(flatten (append (car list) (cdr list))))))
(export 'flatten)
(defun interpolate (x fs xs)
"Uses linear interpolation to estimate f(x), where fs and xs are lists of
corresponding
values (f's) and inputs (x's). The x's must be in increasing order."
(if (< x (first xs))
(first fs)
(loop for last-x in xs
for next-x in (rest xs)
for last-f in fs
for next-f in (rest fs)
until (< x next-x)
finally (return (if (< x next-x)
(+ last-f
(* (- next-f last-f)
(/ (- x last-x)
(- next-x last-x))))