Reinforcement Learning:

A Tutorial
Satinder Singh

Computer Science & Engineering

University of Michigan, Ann Arbor

http://www.eecs.umich.edu/~baveja/ICML06Tutorial/
 Outline
• What is RL?
• Markov Decision Processes (MDPs)
• Planning in MDPs

• Learning in MDPs

• Function Approximation and RL

• Partially Observable MDPs (POMDPs)

• Beyond MDP/POMDPs
RL is Learning from Interaction

Environment

perception action

reward
Agent

• complete agent
• temporally situated
RL is like Life! • continual learning and planning
• object is to affect environment
• environment is stochastic and uncertain
 RL (another view)

Agent’s life Unit of experience

Agent chooses actions so as to maximize expected
cumulative reward over a time horizon

Observations can be vectors or other structures

Actions can be multi-dimensional
Rewards are scalar & can be arbitrarily uninformative
Agent has partial knowledge about its environment
 RL and Machine Learning
1. Supervised Learning (error correction)
• learning approaches to regression & classification
• learning from examples, learning from a teacher

2. Unsupervised Learning
• learning approaches to dimensionality reduction, density
estimation, recoding data based on some principle, etc.

3. Reinforcement Learning
• learning approaches to sequential decision making
• learning from a critic, learning from delayed reward
 Some Key Ideas in RL
• Temporal Differences (or updating a guess on the
basis of another guess)
• Eligibility traces
• Off-policy learning
• Function approximation for RL
• Hierarchical RL (options)
• Going beyond MDPs/POMDPs towards AI
 Model of Agent-Environment Interaction

Model?

Discrete time
Discrete observations
Discrete actions
Markov Decision Processes
(MDPs)
Markov Assumption
Markov Assumption:
 MDP Preliminaries

• S: finite state space

A: finite action space
P: transition probabilities P(i|j,a) [or Pa(ij)]
R: payoff function R(i) or R(i,a)
: deterministic non-stationary policy S -> A
:return for policy when started in state i

Discounted framework

Also, average framework: Vπ = LimT → ∞ Eπ1/T {r0 + r1 + … + rT}

 MDP Preliminaries...

• In MDPs there always exists a deterministic

stationary policy (that simultaneously maximizes
the value of every state)
 Bellman Optimality Equations
Policy Evaluation (Prediction)

Markov assumption!
 Bellman Optimality Equations
Optimal Control
 Graphical View of MDPs
state

action

state Temporal Credit Assignment Problem!!

action
Learning from Delayed Reward
state

action
Distinguishes RL from other forms of ML
state
Planning & Learning
in
MDPs
 Planning in MDPs
• Given an exact model (i.e., reward function,
transition probabilities), and a fixed policy

Value Iteration (Policy Evaluation)

For k = 0,1,2,...

Stopping criterion:

Arbitrary initialization: V0
 Planning in MDPs
Given a exact model (i.e., reward function, transition
probabilities), and a fixed policy

Value Iteration (Policy Evaluation)

For k = 0,1,2,...

Stopping criterion:
Arbitrary initialization: Q0
 Planning in MDPs
Given a exact model (i.e., reward function, transition
probabilities)
Value Iteration (Optimal Control)
For k = 0,1,2,...

Stopping criterion:
Convergence of Value Iteration
2

3
*
1

Contractions!
Proof of the DP contraction
 Learning in MDPs
state
• Have access to the “real
system” but no model
action

state Generate experience

action
This is what life looks like!
state

action Two classes of approaches:

1. Indirect methods
state 2. Direct methods
Indirect Methods for Learning in MDPs
• Use experience data to estimate model

• Compute optimal policy w.r.to estimated model

(Certainly equivalent policy)
• Exploration-Exploitation Dilemma
Model converges asymptotically provided all state-action pairs
are visited infinitely often in the limit; hence certainty equivalent
policy converges asymptotically to the optimal policy
Parametric models
Direct Method: Q-Learning

s0a0r0 s1a1r1 s2a2r2 s3a3r3… skakrk…

A unit of experience < sk ak rk sk+1 >
Update:
Qnew(sk,ak) = (1-!) Qold(sk,ak) +
![rk + " maxb Qold(sk+1,b)]

step-size
Only updates state-action pairs
Big table of Q-values? that are visited...
Watkins, 1988
 So far...
• Q-Learning is the first provably convergent direct
adaptive optimal control algorithm
• Great impact on the field of modern
Reinforcement Learning
• smaller representation than models
• automatically focuses attention to where it is
needed, i.e., no sweeps through state space
• though does not solve the exploration versus
exploitation dilemma
• epsilon-greedy, optimistic initialization, etc,...
 Monte Carlo?
Suppose you want to find for some fixed state s

Start at state s and execute the policy for a long

trajectory and compute the empirical discounted return

Do this several times and average the returns across

trajectories
How many trajectories?

Unbiased estimate whose variance improves with n

 Sparse Sampling
Use generative model
to generate depth ‘n’ tree
with ‘m’ samples for each action
in each state generated

Near-optimal action at root state in

time independent of the size of state space
(but, exponential in horizon!)
Kearns, Mansour & Ng
 Summary
• Space of Algorithms:
• (does not need a model) linear in horizon +
polynomial in states
• (needs generative model) Independent of
states + exponential in horizon
• (needs generative model) time complexity
depends on the complexity of policy class
 Eligibility Traces
(another key idea in RL)
 Eligibility Traces

• The policy evaluation problem: given a (in

general stochastic) policy !, estimate
V!(i) = E!{r0+ "r1 + "2r2 + "3r3+… | s0=i}
from multiple experience trajectories
generated by following policy ! repeatedly
from state i
A single trajectory:
r0 r1 r2 r3 …. rk rk+1 ….
 TD(!)
r0 r1 r2 r3 …. rk rk+1 ….

0-step (e0): r0 + "V(s1)

Vnew(s0) = Vold(s0) + # [r0 + "Vold(s1) - Vold(s0)]

temporal difference

Vnew(s0) = Vold(s0) + # [e0 - Vold(s0)]

TD(0)
 TD(!)
r0 r1 r2 r3 …. rk rk+1 ….

r0 + "V(s1)
1-step (e1): r0 + "r1 + "2V(s2)

Vnew(s0) = Vold(s0) + # [e1 - Vold(s0)]

Vold(s0) + # [r0 + "r1 + "2Vold(s2) - Vold(s0)]
 TD(!)
r0 r1 r2 r3 …. rk rk+1 ….

w0 e0: r0 + "V(s1)
w1 e1: r0 + "r1 + "2V(s2)
w2 e2: r0 + "r1 + "2r2 + "3V(s3)

wk-1 ek-1: r0 + "r1 + "2r2 + "3r3 + … "k-1rk-1 + "k V(sk)

w# e#: r0 + "r1 + "2r2 + "3r3 + … "k rk + "k+1 rk+1 + …

Vnew(s0) = Vold(s0) + $ [%k wk ek - Vold(s0)]

 TD(!)
r0 r1 r2 r3 …. rk rk+1 ….

(1-!) r0 + "V(s1)
(1-!)! r0 + "r1 + "2V(s2)
(1-!)!2 r0 + "r1 + "2r2 + "3V(s3)

(1-!)!k-1 r0 + "r1 + "2r2 + "3r3 + … "k-1rk-1 + "k V(sk)

Vnew(s0) = Vold(s0) + # [$k (1-!)!k ek - Vold(s0)]

0 % ! % 1 interpolates between 1-step TD and Monte-Carlo
 TD(!)
r0 r1 r2 r3 …. rk rk+1 ….

#0 r0 + "V(s1) - V(s0)
#1 r1 + "V(s2) - V(s1)
#2 r2 + "V(s3) - V(s2)

#k rk-1 + "V(sk)-V(sk-1)

Vnew(s0) = Vold(s0) + $ [%k (1-!)!k #k]

eligibility w.p.1 convergence (Jaakkola, Jordan & Singh)

trace
 Bias-Variance Tradeoff
decreasing r0 r1 r2 r3 …. rk rk+1 ….
bias
e0: r0 + !V(s1)
e1: r0 + !r1 + !2V(s2) increasing
variance
e2: r0 + !r1 + !2r2 + !3V(s3)

ek-1: r0 + !r1 + !2r2 + !3r3 + … !k-1rk-1 + !k V(sk)

e": r0 + !r1 + !2r2 + !3r3 + … !k rk + !k+1 rk+1 + …

TD( )
 Bias-Variance Tradeoff
Constant step-size
1$ b!t
errort # a! + b!t
1$ b!
a!
t % &, error asymptotes at
1- b!
( an increasing function of !)
Rate of convergence is b!t (exponential)
b! is a decreasing function of !

Intuition: start with

" large ! and then decrease over time

Kearns & Singh, 2000

 Near-Optimal
Reinforcement Learning in
Polynomial Time
(solving the exploration versus exploitation dilemma)
Function Approximation
and
Reinforcement Learning
 General Idea
s Function Q(s,a)
a Approximator targets or errors

Could be:
• table
gradient-
• Backprop Neural Network descent
• Radial-Basis-Function Network methods

• Tile Coding (CMAC)

• Nearest Neighbor, Memory Based
• Decision Tree
 Neural Networks as FAs
Q(s, a) = f (s, a, w)

weight vector
standard
backprop
gradient
e.g., gradient-descent Sarsa:

w ! w + "[ rt +1 + # Q(st +1 , at +1 ) $ Q(st ,at )] %w f (st ,at , w)

estimated value
target value
Linear in the Parameters FAs
rT r r
ˆ
V (s) = ! "s #!rVˆ (s) = " s
r
Each state s represented by a feature vector "s
r
Or represent a state-action pair with "sa
and approximate action values:

$ 2
Q (s, a) = E r1 + %r2 + % r3 +L s t = s, at = a, $
rT r
Qˆ (s,a) = ! " s,a
 Sparse Coarse Coding

.
.
.
. Linear
fixed expansive .
. last
Re-representation . layer
.
.
.
.
features

Coarse: Large receptive fields

Sparse: Few features present at one time
Shaping Generalization in Coarse
Coding
 FAs & RL
• Linear FA (divergence can happen)
Nonlinear Neural Networks (theory is not well developed)
Non-parametric, e.g., nearest-neighbor (provably not
divergent; bounds on error)
Everyone uses their favorite FA… little theoretical
guidance yet!
• Does FA really beat the curse of dimensionality?
• Probably; with FA, computation seems to scale with the
complexity of the solution (crinkliness of the value function) and
how hard it is to find it
• Empirically it works
• though many folks have a hard time making it so
• no off-the-shelf FA+RL yet
Off-Policy Learning
• Learning about a way of behaving
while behaving in some other way
 Importance Sampling
• Behave according to policy µ
• Evaluate policy π
• Episode (e): s a r s r … s a r s
0 0 1 1 2 T-1 T-1 T T

• Pr(e|π) = Π T-1 π(a | s ) Pr(s |s ,a )

k=0 k k k+1 k k

• Importance Sampling Ratio:

High variance
 Off-Policy with Linear
Function Approximation

Precup, Sutton & Dasgupta

 After MDPs...

• Great success with MDPs

• What next?
• Rethinking Actions, States, Rewards
• Options instead of actions
• POMDPs
Rethinking Action
(Hierarchical RL)
Options
(Precup, Sutton, Singh)

MAXQ by Dietterich
HAMs by Parr & Russell
Abstraction in Learning and Planning

• A long-standing, key problem in AI !

• How can we give abstract knowledge a clear semantics?

e.g. “I could go to the library”
• How can different levels of abstraction be related?
! spatial: states
! temporal: time scales
• How can we handle stochastic, closed-loop, temporally
extended courses of action?

• Use RL/MDPs to provide a theoretical foundation

 Options
A generalization of actions to include courses of action

An option is a triple o =< I, ! , " >

• I $S is the set of states in which o may be started

• ! :S%A& [0,1] is the policy followed during o
• " :S& [0,1] is the probability of terminating in each state

Option execution is assumed to be call-and-return

# Example: docking
I : all states in which charger is in sight
! : hand-crafted controller
" : terminate when docked or charger not visible

Options can take variable number of steps

 Rooms Example

4 rooms
4 hallways
4 unreliable
ROOM HALLWAYS primitive actions
up

left right Fail 33%

of the time
O1
down

G? 8 multi-step options
O2 G? (to each room's 2 hallways)

Given goal location,

quickly plan shortest route

Goal states are given All rewards zero

a terminal value of 1 ! = .9
Options define a Semi-Markov Decison
Process (SMDP)
Time

MDP Discrete time

State Homogeneous discount

Continuous time
SMDP Discrete events
Interval-dependent discount

Options Discrete time

over MDP Overlaid discrete events
Interval-dependent discount

A discrete-time SMDP overlaid on an MDP

Can be analyzed at either level
 MDP + Options = SMDP

Theorem:
For any MDP,
and any set of options,
the decision process that chooses among the options,
executing each to termination,
is an SMDP.

Thus all Bellman equations and DP results extend for

value functions over options and models of options
(cf. SMDP theory).
 What does the SMDP connection give us?
• Policies over options : µ :S"O # [0,1]
• Value functions over options : V µ (s), Qµ (s,o), VO* (s), QO* (s,o)
• Learning methods : Bradtke & Duff (1995), Parr (1998)
• Models of options
• Planning methods : e.g. value iteration, policy iteration, Dyna...
• A coherent theory of learning and planning with courses of
action at variable time scales, yet at the same level
A theoretical fondation for what we really need!

! But the most interesting issues are beyond SMDPs...

 Value Functions for Options

Define value functions for options, similar to the MDP case

V µ (s) = E {rt+1 + ! rt+2 + ... | E( µ ,s,t)}

Q µ (s,o) = E {rt+1 + ! rt+2 + ... | E(oµ ,s, t)}

Now consider policies µ "#(O) restricted to choose only

from options in O :

VO* (s) = max V µ (s)

µ"# (O)

QO* (s,o) = max Q µ (s,o)

µ "#(O)
 Models of Options
Knowing how an option is executed is not enough for reasoning about
it, or planning with it. We need information about its consequences

The model of the consequences of starting option o in state s has :

• a reward part
rso = E{r1 + " r2 + ...+ " k#1rk | s0 = s, o taken in s0 , lasts k steps}
• a next - state part
o
pss' = E{" k$sk s' | s0 = s, o taken in s0 , lasts k steps}
%
1 if s'= sk is the termination state, 0 otherwise

This form follows from SMDP theory. Such models can be used
!
interchangeably with models of primitive actions in Bellman equations.
 Room Example

4 rooms
4 hallways
4 unreliable
ROOM HALLWAYS primitive actions
up

left right Fail 33%

of the time
O1
down

G? 8 multi-step options
O2 G? (to each room's 2 hallways)

Given goal location,

quickly plan shortest route

Goal states are given All rewards zero

a terminal value of 1 ! = .9
n
Example: Synchronous Value Iteration
Generalized to Options

Initialize : V0 (s) " 0 #s $ S

Iterate : Vk+1 (s) " max[rso + % pss'

o
Vk (s')] #s $ S
o$O s'$S

The algorithm converges to the optimal value function,given the options :

lim Vk = VO*
k &'
Once VO* is computed, µO* is readily determined.

If O = A, the algorithm reduces to conventional value iteration

If A ( O, then VO* = V *

!
 Rooms Example

with cell-to-cell
primitive actions

V(goal )=1

Iteration #0 Iteration #1 Iteration #2

with room-to-room
options

V(goal )=1

Iteration #0 Iteration #1 Iteration #2

 Example with Goal!Subgoal
both primitive actions and options

Initial values Iteration #1 Iteration #2

Iteration #3 Iteration #4 Iteration #5

 What does the SMDP connection give us?

• Policies over options : µ : S ! O a [0,1]

• Value functions over options : V µ (s), Qµ (s, o), VO* (s), QO* (s,o)
• Learning methods : Bradtke & Duff (1995), Parr (1998)
• Models of options
• Planning methods : e.g. value iteration, policy iteration, Dyna...
• A coherent theory of learning and planning with courses of
action at variable time scales, yet at the same level

A theoretical foundation for what we really need!

But the most interesting issues are beyond SMDPs...

 Advantages of Dual MDP/SMDP View

At the SMDP level

Compute value functions and policies over options
with the benefit of increased speed / flexibility

At the MDP level

Learn how to execute an option for achieving a
given goal

Between the MDP and SMDP level

Improve over existing options (e.g. by terminating early)
Learn about the effects of several options in parallel,
without executing them to termination
 Between MDPs and SMDPs

• Termination Improvement
Improving the value function by changing the termination
conditions of options

• Intra-Option Learning
Learning the values of options in parallel, without executing them
to termination
Learning the models of options in parallel, without executing
them to termination

• Tasks and Subgoals

Learning the policies inside the options
 Termination Improvement
Idea: We can do better by sometimes interrupting ongoing options
- forcing them to terminate before ! says to

Theorem : For any policy over options µ :S#O $ [0,1],

suppose we interrupt its options one or more times, when

Qµ (s,o) < Qµ (s, µ(s)), where s is the state at that time

o is the ongoing option
to obtain µ':S#O'$ [0,1],
Then µ' > µ (it attains more or equal reward everywhere)

Application : Suppose we have determined QO* and thus µ = µO* .

Then µ' is guaranteed better than µO*
and is available with no additional computation.

"
 Landmarks Task

range (input set) of each Task: navigate from S to G as

run-to-landmark controller
G fast as possible

4 primitive actions, for taking

tiny steps up, down, left, right

7 controllers for going straight

landmarks
to each one of the landmarks,
from within a circular region
S where the landmark is visible

In this task, planning at the level of primitive actions is

computationally intractable, we need the controllers
 Illustration: Reconnaissance
Mission Planning (Problem)
• Mission: Fly over (observe) most
25 valuable sites and return to base
15 (reward)
• Stochastic weather affects
25 (mean time between observability (cloudy or clear) of sites
50 weather changes)
• Limited fuel
8
options • Intractable with classical optimal
control methods

50
• Temporal scales:
! Actions: which direction to fly now
! Options: which site to head for
5
• Options compress space and time
100 10
! Reduce steps from ~600 to ~6
50 ! Reduce states from ~1011 to ~106

Base * o o *
100 decision steps QO (s, o) = rs + " ps s! VO ( s!)
s!
any state (106) sites only (6)
 Illustration: Reconnaissance
Mission Planning (Results)
• SMDP planner:
Expected Reward/Mission ! Assumes options followed to
completion
! Plans optimal SMDP solution
60 • SMDP planner with re-evaluation
! Plans as if options must be followed to
50 completion
! But actually takes them for only one
40 step
High Fuel
Low Fuel ! Re-picks a new option on every step
30
SMDP SMDP Static • Static planner:
planner Planner Re-planner ! Assumes weather will not change
with ! Plans optimal tour among clear sites
re-evaluation Temporal abstraction ! Re-plans whenever weather changes
of options on finds better approximation
each step
than static planner, with
little more computation
than SMDP planner
Example of Intra-Option Value Learning
0
Value of Optimal Policy
Learned value
Upper
-2 -1 hallway
True value option
Average Option
-2
-3 value of values
greedy policy Learned value
-3
Left
-4
True value hallway
option
-4
1 10 100 1000 6000 0 1000 2000 3000 4000 5000 6000
Episodes Episodes

Random start, goal in right hallway, random actions

Intra-option methods learn correct values without ever

taking the options! SMDP methods are not applicable here
 Intra-Option Model Learning

4 Reward State
Max error prediction 0.7
prediction
3 error 0.6
error
SMDP
0.5
Intra
2 SMDP 1/t 0.4
Avg. error SMDP
0.3

1 0.2 SMDP 1/t Max

SMDP error
SMDP 1/t Intra
0.1
Intra SMDP 1/t SMDP Avg.
0 0 Intra error
0 20,000 40,000 60,000 80,000 100,000 0 20,000 40,000 60,000 80,000 100,000
Options executed Options executed

Random start state, no goal, pick randomly among all options

Intra-option methods work much faster than SMDP methods

 Tasks and Subgoals

It is natural to define options as solutions to subtasks

e.g. treat hallways as subgoals, learn shortest paths

We have defined subgoals as pairs : <G,g >

G"S is the set of states treated as subgoals
g :G# $ are their subgoal values (can be both good and bad)

Each subgoal has its own set of value functions, e.g.:

Vgo (s) = E{r1 + % r2 + ...+ % k&1rk + g(sk ) | s0 = s, o, sk 'G}
Vg* (s) = max Vgo (s)
o

Policies inside options can be learned from subgoals,

in intra - option, off - policy manner.
 Between MDPs and SMDPs

• Termination Improvement
Improving the value function by changing the termination
conditions of options

• Intra-Option Learning
Learning the values of options in parallel, without executing them
to termination
Learning the models of options in parallel, without executing
them to termination

• Tasks and Subgoals

Learning the policies inside the options
 Summary: Benefits of Options
• Transfer
! Solutions to sub-tasks can be saved and reused
! Domain knowledge can be provided as options and subgoals
• Potentially much faster learning and planning
! By representing action at an appropriate temporal scale
• Models of options are a form of knowledge representation
! Expressive
! Clear
! Suitable for learning and planning
• Much more to learn than just one policy, one set of values
! A framework for “constructivism” – for finding models of the
world that are useful for rapid planning and learning