Lecture 14 | Deep Reinforcement Learning

Lecture 14 | Deep Reinforcement Learning

November 21, 2019 0 By Stanley Isaacs


– Okay let’s get started. Alright, so welcome to lecture 14, and today we’ll be talking
about reinforcement learning. So some administrative details first, update on grades. Midterm grades were released last night, so see Piazza for more information and statistics about that. And we also have A2 and milestone grades scheduled for later this week. Also, about your projects, all teams must register your projects. So on Piazza we have a form posted, so you should go there and
this is required, every team should go and fill out
this form with information about your project, that
we’ll use for final grading and the poster session. And the Tiny ImageNet
evaluation servers are also now online for those of you who are doing the Tiny ImageNet challenge. We also have a link to a
course survey on Piazza that was released a few days ago, so, please fill it out if
you guys haven’t already. We’d love to have your
feedback and know how we can improve this class. Okay, so the topic of today,
reinforcement learning. Alright, so so far we’ve talked
about supervised learning, which is about a type of
problem where we have data x and then we have labels y
and our goal is to learn a function that is mapping from x to y. So, for example, the
classification problem that we’ve been working with. We also talked last lecture
about unsupervised learning, which is the problem
where we have just data and no labels, and our goal is to learn some underlying, hidden
structure of the data. So, an example of this
is the generative models that we talked about last lecture. And so today we’re going
to talk about a different kind of problem set-up, the
reinforcement learning problem. And so here we have an agent that can take actions in its environment, and it can receive rewards
for for its action. And its goal is going to be
to learn how to take actions in a way that can maximize its reward. And so we’ll talk about this
in a lot more detail today. So, the outline for today,
we’re going to first talk about the reinforcement
learning problem, and then we’ll talk about
Markov decision processes, which is a formalism of the
reinforcement learning problem, and then we’ll talk
about two major classes of RL algorithms, Q-learning
and policy gradients. So, in the reinforcement
learning set up, what we have is we have an agent and
we have an environment. And so the environment
gives the agent a state. In turn, the agent is
going to take an action, and then the environment is
going to give back a reward, as well as the next state. And so this is going to
keep going on in this loop, on and on, until the environment gives back a terminal state, which then ends the episode. So, let’s see some examples of this. First we have here the cart-pole problem, which is a classic problem
that some of you may have seen, in, for example, 229 before. And so this objective
here is that you want to balance a pole on top of a movable cart. Alright, so the state
that you have here is your current description of the system. So, for example, angular, angular speed of your pole, your
position, and the horizontal velocity of your cart. And the actions you can
take are horizontal forces that you apply onto the cart, right? So you’re basically trying
to move this cart around to try and balance this pole on top of it. And the reward that you’re getting from this environment
is one at each time step if your pole is upright. So you basically want to keep this pole balanced for as long as you can. Okay, so here’s another example
of a classic RL problem. Here is robot locomotion. So we have here an example
of a humanoid robot, as well as an ant robot model. And our objective here is to
make the robot move forward. And so the state that we have describing our system is
the angle and the positions of all the joints of our robots. And then the actions that we can take are the torques applied onto these joints, right, and so these are trying to make the robot move forward and then
the reward that we get is our forward movement as well
as, I think, in the time of, in the case of the humanoid,
also, you can have something like a reward of one for
each time step that this robot is upright. So, games are also a big class of problems that
can be formulated with RL. So, for example, here we have Atari games which are a classic success
of deep reinforcement learning and so here the objective
is to complete these games with the highest possible score, right. So, your agent is basically a player that’s trying to play these games. And the state that you have is going to be the raw pixels of the game state. Right, so these are just the pixels on the screen that you would see as you’re playing the game. And then the actions that you have are your game controls, so for example, in some games maybe moving
left to right, up or down. And then the score that you
have is your score increase or decrease at each time step,
and your goal is going to be to maximize your total score
over the course of the game. And, finally, here we have
another example of a game here. It’s Go, which is something that was a huge achievement of deep
reinforcement learning last year, when Deep Minds AlphaGo beats Lee Sedol, which is one of the best Go players of the last few years, and this is actually in the news again for, as some of you may have
seen, there’s another Go competition going on now with AlphaGo versus a top-ranked Go player. And so the objective here is to win the game, and our
state is the position of all the pieces, the action
is where to put the next piece down, and the reward
is, one, if you win at the end of the game, and zero otherwise. And we’ll also talk about this one in a little bit more detail, later. Okay, so how can we mathematically formalize the RL problem, right? This loop that we talked about earlier, of environments giving agents states, and then agents taking actions. So, a Markov decision process is the mathematical formulation
of the RL problem, and an MDP satisfies the Markov property, which is that the current state completely characterizes the state of the world. And an MDP here is defined
by tuple of objects, consisting of S, which is
the set of possible states. We have A, our set of possible actions, we also have R, our
distribution of our reward, given a state, action pair, so it’s a function
mapping from state action to your reward. You also have P, which is
a transition probability distribution over your
next state, that you’re going to transition to given
your state, action pair. And then finally we have a
Gamma, a discount factor, which is basically
saying how much we value rewards coming up soon versus later on. So, the way the Markov
Decision Process works is that at our initial time step t equals zero, the environment is going to sample some initial state as zero, from
the initial state distribution, p of s zero. And then, once it has that,
then from time t equals zero until it’s done, we’re going
to iterate through this loop where the agent is going to
select an action, a sub t. The environment is going to
sample a reward from here, so reward given your state and the action that you just took. It’s also going to sample the next state, at time t plus one, given
your probability distribution and then the agent is going to receive the reward, as well as the
next state, and then we’re going to through this process again, and keep looping; agent
will select the next action, and so on until the episode is over. Okay, so now based on this, we
can define a policy pi, which is a function from
your states to your actions that specifies what action
to take in each state. And this can be either
deterministic or stochastic. And our objective now is
to going to be to find your optimal policy pi
star, that maximizes your cumulative discounted reward. So we can see here we have our some of our future
rewards, which can be also discounted by your discount factor. So, let’s look at an
example of a simple MDP. And here we have Grid World, which is this task where we have this grid of states. So you can be in any of these cells of your grid, which are your states. And you can take actions from your states, and so these actions are going to be simple movements, moving to your right, to your left, up or down. And you’re going to get a
negative reward for each transition or each time step,
basically, that happens. Each movement that you take, and this can be something
like R equals negative one. And so your objective is going to be to reach one of the terminal states, which are the gray states shown here, in the least number of actions. Right, so the longer
that you take to reach your terminal state, you’re going to keep accumulating these negative rewards. Okay, so if you look at
a random policy here, a random policy would
consist of, basically, at any given state or cell that you’re in just sampling randomly which direction that you’re going to move in next. Right, so all of these
have equal probability. On the other hand, an optimal policy that we would like to have is basically taking the action, the direction that will move us closest
to a terminal state. So you can see here, if we’re right next to one of the terminal states we should always move in the direction that gets us to this terminal state. And otherwise, if you’re in
one of these other states, you want to take the
direction that will take you closest to one of these states. Okay, so now given this description of our MDP, what we want to do is we want to find our
optimal policy pi star. Right, our policy that’s
maximizing the sum of the rewards. And so this optimal policy
is going to tell us, given any state that we’re
in, what is the action that we should take in order
to maximize the sum of the rewards that we’ll get. And so one question is how do we handle the randomness in the MDP, right? We have randomness in terms of our initial
state that we’re sampling, in therms of this transition probability distribution that will give us distribution of our
next states, and so on. Also what we’ll do is we’ll
work, then, with maximizing our expected sum of the rewards. So, formally, we can write
our optimal policy pi star as maximizing this expected
sum of future rewards over policy’s pi, where
we have our initial state sampled from our state distribution. We have our actions, sampled from our policy, given the state. And then we have our next states sampled from our transition
probability distributions. Okay, so before we talk about exactly how we’re going
to find this policy, let’s first talk about a few definitions that’s going to be helpful
for us in doing so. So, specifically, the value function and the Q-value function. So, as we follow the policy, we’re going to sample trajectories or paths, right, for every episode. And we’re going to have
our initial state as zero, a-zero, r-zero, s-one,
a-one, r-one, and so on. We’re going to have this trajectory of states, actions, and
rewards that we get. And so, how good is a state
that we’re currently in? Well, the value function at any state s, is the expected cumulative reward following the policy from
state s, from here on out. Right, so it’s going to be expected value of our expected cumulative reward, starting from our current state. And then how good is a state, action pair? So how good is taking action a in state s? And we define this using
a Q-value function, which is, the expected
cumulative reward from taking action a in state s and
then following the policy. Right, so then, the
optimal Q-value function that we can get is going to be
Q star, which is the maximum expected cumulative reward that we can get from a given state action
pair, defined here. So now we’re going to
see one important thing in reinforcement learning, which is called the Bellman equation. So let’s consider this a Q-value function from the optimal policy Q star, which is then going to
satisfy this Bellman equation, which is this identity shown here, and what this means is that given any state, action pair, s and a, the value of this pair
is going to be the reward that you’re going to get, r,
plus the value of whatever state that you end up in. So, let’s say, s prime. And since we know that we
have the optimal policy, then we also know that we’re going to play the best action that we can, right, at our state s prime. And so then, the value at state s prime is just going to be the
maximum over our actions, a prime, of Q star at s prime, a prime. And so then we get this identity here, for optimal Q-value. Right, and then also, as always, we have this expectation here, because we have randomness over what state that we’re going to end up in. And then we can also
infer, from here, that our optimal policy, right, is going to consist of taking the best action in any state, as specified by Q star. Q star is going to tell us of the maximum future reward that we can
get from any of our actions, so we should just take a policy that’s following this and just taking the action that’s going to lead to best reward. Okay, so how can we solve
for this optimal policy? So, one way we can solve for this is something called a value
iteration algorithm, where we’re going to use
this Bellman equation as an iterative update. So at each step, we’re going
to refine our approximation of Q star by trying to
enforce the Bellman equation. And so, under some
mathematical conditions, we also know that this sequence Q, i of our Q-function is going
to converge to our optimal Q star as i approaches infinity. And so this, this works well, but what’s the problem with this? Well, an important problem
is that this is not scalable. Right? We have to compute Q of s, a here for
every state, action pair in order to make our iterative updates. Right, but then this is a problem if, for example, if we look at these the state of, for example, an Atari game that we had earlier, it’s going to be your screen of pixels. And this is a huge state
space, and it’s basically computationally infeasible to compute this for
the entire state space. Okay, so what’s the solution to this? Well, we can use a function approximator to estimate Q of s, a so, for example, a neural network, right. So, we’ve seen before that
any time, if we have some really complex function that
don’t know, that we want to estimate, a neural network is a good way to estimate this. Okay, so this is going to take us to our formulation of Q-learning
that we’re going to look at. And so, what we’re going
to do is we’re going to use a function approximator in order to estimate our
action value function. Right? And if this function approximator is a deep neural network, which is what’s been used recently, then this is going to be
called deep Q-learning. And so this is something that you’ll hear around as one
of the common approaches to deep reinforcement
learning that’s in use. Right, and so in this case, we also have our function parameters theta here, so our Q-value function is determined by these weights, theta, of our neural network. Okay, so given this
function approximation, how do we solve for our optimal policy? So remember that we want to find a Q-function that’s satisfying
the Bellman equation. Right, and so we want to
enforce this Bellman equation to happen, so what we
can do when we have this neural network approximating
our Q-function is that we can train this where our loss function is going to try and minimize the error of our Bellman equation, right? Or how far q of s, a is from its target, which is the Y_i here,
the right hand side of the Bellman equation
that we saw earlier. So, we’re basically going to take these forward passes of our loss function, trying
to minimize this error and then our backward
pass, our gradient update, is just going to be you just take the gradient of this loss, with respect to our
network parameter’s theta. Right, and so our goal is again to have this effect as we’re
taking gradient steps of iteratively trying
to make our Q-function closer to our target value. So, any questions about this? Okay. So let’s look at a case
study of an example where one of the classic examples
of deep reinforcement learning where this approach was applied. And so we’re going to look at
this problem that we saw earlier of playing Atari games,
where our objective was to complete the game
with the highest score and remember our state is
going to be the raw pixel inputs of the game state, and we can take these actions of moving left, right, up, down, or whatever actions of
the particular game. And our reward at each time
step, we’re going to get a reward of our score
increase or decrease that we got at this time step, and
so our cumulative total reward is this total reward
that we’ll usually see at the top of the screen. Okay, so the network that
we’re going to use for our Q-function is going to
look something like this, right, where we have our
Q-network, with weight’s theta. And then our input, our
state s, is going to be our current game screen. And in practice we’re going to take a stack of the last four
frames, so we have some history. And so we’ll take these raw pixel values, we’ll do some, you know, RGB
to gray-scale conversions, some down-sampling, some cropping, so, some pre-processing. And what we’ll get out of
this is this 84 by 84 by four stack of the last four frames. Yeah, question. [inaudible question from audience] Okay, so the question
is, are we saying here that our network is
going to approximate our Q-value function for
different state, action pairs, for example, four of these? Yeah, that’s correct. We’ll see, we’ll talk about that in a few slides. [inaudible question from audience] So, no. So, we don’t have a Softmax
layer after the connected, because here our goal
is to directly predict our Q-value functions. [inaudible question from audience] Q-values. [inaudible question from audience] Yes, so it’s more doing
regression to our Q-values. Okay, so we have our input to this network and then on top of this,
we’re going to have a couple of familiar convolutional layers, and a fully-connected layer, so here we have an eight-by-eight
convolutions and we have some four-by-four convolutions. Then we have a FC 256 layer, so this is just a standard kind of networK that you’ve seen before. And then, finally, our last
fully-connected layer has a vector of outputs, which
is corresponding to your Q-value for each action, right, given the state that you’ve input. And so, for example, if
you have four actions, then here we have this
four-dimensional output corresponding to Q of
current s, as well as a-one, and then a-two, a-three, and a-four. Right so this is going
to be one scalar value for each of our actions. And then the number of
actions that we have can vary between, for example, 4 to 18,
depending on the Atari game. And one nice thing here is that using this network structure, a single feedforward
pass is able to compute the Q-values for all functions from the current state. And so this is really efficient. Right, so basically we
take our current state in and then because we have
this output of an action for each, or Q-value for each
action, as our output layer, we’re able to do one pass and
get all of these values out. And then in order to train this, we’re just going to use our
loss function from before. Remember, we’re trying to
enforce this Bellman equation and so, on our forward
pass, our loss function we’re going to try and
iteratively make our Q-value close to our target value, that it should have. And then our backward pass is just directly taking the gradient of this loss function that we have and then taking a gradient step based on that. So one other thing that’s used
here that I want to mention is something called experience replay. And so this addresses a
problem with just using the plain two network
that I just described, which is that learning from batches of consecutive samples is bad. And so the reason because of this, right, is so for just playing the game, taking samples of state action rewards that we have and just taking consecutive
samples of these and training with these, well all of these samples are correlated and so this leads to inefficient learning, first of all, and also, because of this,
our current Q-network parameters, right, this
determines the policy that we’re going to follow,
it determines our next samples that we’re going to get that we’re going to use for training. And so this leads to problems where you can have bad feedback loops. So, for example, if
currently the maximizing action that’s going to take left, well this is going to bias all of my upcoming training examples to be dominated by samples from the left-hand side. And so this is a problem, right? And so the way that we
are going to address these problems is by using something called experience replay, where
we’re going to keep this replay memory table of
transitions of state, as state, action, reward, next state, transitions that we have, and we’re going to continuously update this
table with new transitions that we’re getting as
game episodes are played, as we’re getting more experience. Right, and so now what we can do is that we can now train
our Q-network on random, mini-batches of transitions
from the replay memory. Right, so instead of
using consecutive samples, we’re now going to sample across these transitions that we’ve accumulated
random samples of these, and this breaks all of the, these correlation problems
that we had earlier. And then also, as another side benefit is that
each of these transitions can also contribute to potentially
multiple weight updates. We’re just sampling from this table and so we could sample one multiple times. And so, this is going to lead also to greater data efficiency. Okay, so let’s put this all together and let’s look at the full algorithm for deep Q-learning
with experience replay. So we’re going to start off with
initializing our replay memory to some capacity that we
choose, N, and then we’re also going to initialize our Q-network, just with our random weights or initial weights. And then we’re going to play
M episodes, or full games. This is going to be our training episodes. And then what we’re going to do is we’re going to initialize our state, using the starting game screen pixels at the beginning of each episode. And remember, we go through
the pre-processing step to get to our actual input state. And then for each time step of a game that we’re currently playing, we’re going to, with a small probability, select a random action, so one thing that’s
important in these algorithms is to have sufficient exploration, so we want to make sure that we are sampling different
parts of the state space. And then otherwise, we’re going to select from the greedy action from the current policy. Right, so most of the time
we’ll take the greedy action that we think is a good policy of the type of
actions that we want to take and states that we want to see,
and with a small probability we’ll sample something random. Okay, so then we’ll take this action, a, t, and we’ll observe the
next reward and the next state. So r, t and s, t plus one. And then we’ll take this and
we’ll store this transition in our replay memory
that we’re building up. And then we’re going to take, we’re going to train a
network a little bit. So we’re going to do experience replay and we’ll take a sample
of a random mini-batches of transitions that we have from the replay memory,
and then we’ll perform a gradient descent step on this. Right, so this is going to
be our full training loop. We’re going to be
continuously playing this game and then also sampling minibatches, using
experienced replay to update our weights of our Q-network and then continuing in this fashion. Okay, so let’s see. Let’s see if I can, is this playing? Okay, so let’s take a look at this deep Q-learning algorithm from Google DeepMind, trained
on an Atari game of Breakout. Alright, so it’s saying
here that our input is just going to be our
state are raw game pixels. And so here we’re looking
at what’s happening at the beginning of training. So we’ve just started training a bit. And right, so it’s going to look to it’s learned to kind of hit the ball, but it’s not doing a very
good job of sustaining it. But it is looking for the ball. Okay, so now after some more training, it looks like a couple hours. Okay, so now it’s learning
to do a pretty good job here. So it’s able to continuously follow this ball and be able to to remove most of the blocks. Right, so after 240 minutes. Okay, so here it’s found
the pro strategy, right? You want to get all the
way to the top and then have it go by itself. Okay, so this is an example of using deep Q-learning in order to train an agent to be
able to play Atari games. It’s able to do this on many Atari games and so you can check out some more of this online. Okay, so we’ve talked about Q-learning. But there is a problem
with Q-learning, right? It can be challenging
and what’s the problem? Well, the problem can be that the Q-function is very complicated. Right, so we have to, we’re
saying that we want to learn the value of every state action pair. So, if, let’s say you have
something, for example, a robot grasping, wanting
to grasp an object. Right, you’re going to have a
really high dimensional state. You have, I mean, let’s
say you have all of your even just joint, joint
positions, and angles. Right, and so learning the
exact value of every state action pair that you have, right, can be really, really hard to do. But on the other hand, your
policy can be much simpler. Right, like what you want this robot to do maybe just to have this simple motion of just closing your hand, right? Just, move your fingers in this particular direction and keep going. And so, that leads to the question of can we just learn this policy directly? Right, is it possible,
maybe, to just find the best policy from a collection of policies, without trying to go through this process of estimating your Q-value and then using that to infer your policy. So, this is an approach that oh, so, okay, this is an approach that we’re going to call policy gradients. And so, formally, let’s define a class of parametrized policies. Parametrized by weights theta, and so for each policy let’s define the value of the policy. So, J, our value J,
given parameters theta, is going to be, or expected some cumulative sum of future
rewards that we care about. So, the same reward that we’ve been using. And so our goal then, under this setup is that we want to find an optimal policy, theta star, which is the maximum, right, arg max over theta of J of theta. So we want to find the
policy, the policy parameters that gives our best expected reward. So, how can we do this? Any ideas? Okay, well, what we can do is just a gradient assent on
our policy parameters, right? We’ve learned that given
some objective that we have, some parameters we can
just use gradient asscent and gradient assent in order to continuously improve our parameters. And so let’s talk more
specifically about how we can do this, which we’re going to call here the reinforce algorithm. So, mathematically, we can write out our expected future reward over trajectories, and
so we’re going to sample these trajectories of experience, right, like for example episodes of game play that we talked about earlier. S-zero, a-zero, r-zero, s-one, a-one, r-one, and so on. Using some policy pi of theta. Right, and then so, for each trajectory we can compute a reward
for that trajectory. It’s the cumulative reward that we got from following this trajectory. And then the value of a policy, pi sub theta, is going
to be just the expected reward of these
trajectories that we can get from the following pi sub theta. So that’s here, this
expectation over trajectories that we can get, sampling
trajectories from our policy. Okay. So, we want to do gradient ascent, right? So let’s differentiate this. Once we differentiate
this, then we can just take gradient steps, like normal. So, the problem is that
now if we try and just differentiate this exactly, this is intractable, right? So, the gradient of an
expectation is problematic when p is dependent on
theta here, because here we want to take this gradient of p of tau, given theta, but this is going to be, we want to take this integral over tau. Right, so this is intractable. However, we can use a trick
here to get around this. And this trick is taking this
gradient that we want, of p. We can rewrite this by just multiplying this by one, by multiplying top and bottom, both by p of tau given theta. Right, and then if we look at these terms that we have now here, in the
way that I’ve written this, on the left and the right, this is actually going to be equivalent to p of tau times our gradient with respect to theta, of log, of p. Right, because the gradient
of the log of p is just going to be one over p times gradient of p. Okay, so if we then inject this back into our expression that we
had earlier for this gradient, we can see that, what this
will actually look like, right, because now we
have a gradient of log p times our probabilities of
all of these trajectories and then taking this
integral here, over tau. This is now going to be an expectation over our trajectories tau,
and so what we’ve done here is that we’ve taken a
gradient of an expectation and we’ve transformed it into
an expectation of gradients. Right, and so now we can use sample trajectories that we can get in order to estimate our gradient. And so we do this using
Monte Carlo sampling, and this is one of the
core ideas of reinforce. Okay, so looking at this expression that we want to compute, can we compute these
quantities that we had here without knowing the
transition probabilities? Alright, so we have that
p of tau is going to be the probability of a trajectory. It’s going to be the product of all of our transition
probabilities of the next state that we get, given our
current state and action as well as our probability
of the actions that we’ve taken under our policy pi. Right, so we’re going to
multiply all of these together, and get our probability of our trajectory. So this log of p of tau
that we want to compute is going to be we just
take this log and this will separate this out into a sum of pushing the logs inside. And then here, when we differentiate this, we can see we want to
differentiate with respect to theta, but this first
term that we have here, log p of the state
transition probabilities there’s no theta term here, and so the only place where we have
theta is the second term that we have, of log of pi sub theta, of our action, given our
state, and so this is the only term that we keep in our gradient estimate,
and so we can see here that this doesn’t depend on the
transition probabilities, right, so we actually don’t need to know our transition probabilities
in order to computer our gradient estimate. And then, so, therefore
when we’re sampling these, for any given trajectory tau,
we can estimate J of theta using this gradient estimate. This is here shown for a single trajectory from what we had earlier, and then we can also sample
over multiple trajectories to get the expectation. Okay, so given this gradient
estimator that we’ve derived, the interpretation that we can
make from this here, is that if our reward for a trajectory
is high, if the reward that we got from taking the
sequence of actions was good, then let’s push up the
probabilities of all the actions that we’ve seen. Right, we’re just going to say that these were good actions that we took. And then if the reward is low, we want to push down these probabilities. We want to say these were bad actions, let’s try and not sample these so much. Right and so we can see
that’s what’s happening here, where we have pi of a, given s. This is the likelihood of
the actions that we’ve taken and then we’re going to scale
this, we’re going to take the gradient and the gradient
is going to tell us how much should we change the
parameters in order to increase our likelihood of our action, a, right? And then we’re going to
take this and scale it by how much reward we actually got from it, so how good were these
actions, in reality. Okay, so this might seem simplistic to say that, you know, if a trajectory
is good, then we’re saying here that all of its actions were good. Right? But, in expectation, this
actually averages out. So we have an unbiased estimator here, and so if you have many samples of this, then we will get an accurate
estimate of our gradient. And this is nice because we can just take gradient steps and we know
that we’re going to be improving our loss
function and getting closer to, at least some local optimum of our policy parameters theta. Alright, but there is a problem with this, and the problem is that this also suffers from high variance. Because this credit
assignment is really hard. Right, we’re saying that given a reward that we
got, we’re going to say all of the actions were good,
we’re just going to hope that this assignment of
which actions were actually the best actions, that mattered, are going to average out over time. And so this is really hard
and we need a lot of samples in order to have a good estimate. Alright, so this leads to the
question of, is there anything that we can do to reduce the variance and improve the estimator? And so variance reduction is an important area of research
in policy gradients, and in coming up with
ways in order to improve the estimator and require fewer samples. Alright, so let’s look
at a couple of ideas of how we can do this. So given our gradient estimator, so the first idea is that we can push up the probabilities of an action only by it’s affect on future rewards from that state, right? So, now with instead of scaling this likelihood, or
pushing up this likelihood of this action by the total
reward of its trajectory, let’s look more
specifically at just the sum of rewards coming from this time step on to the end, right? And so, this is basically saying that how good an action is, is
only specified by how much future reward it generates. Which makes sense. Okay, so a second idea
that we can also use is using a discount factor in order to ignore delayed effects. Alright so here we’ve added
back in this discount factor, that we’ve seen before,
which is saying that we are, you know, our discount
factor’s going to tell us how much we care about just the rewards that are coming up soon, versus rewards that came much later on. Right, so we were going to now say how good or bad an action is, looking more at the local neighborhood of action set it generates
in the immediate near future and down weighting the the
ones that come later on. Okay so these are some straightforward ideas that are generally used in practice. So, a third idea is this idea of using a baseline in order to
reduce your variance. And so, a problem with
just using the raw value of your trajectories, is that this isn’t necessarily meaningful, right? So, for example, if your
rewards are all positive, then you’re just going to keep pushing up the probabilities of all your actions. And of course, you’ll push
them up to various degrees, but what’s really important
is whether a reward is better or worse than what you’re
expecting to be getting. Alright, so in order to
address this, we can introduce a baseline function that’s
dependent on the state. Right, so this baseline function tell us what’s, how much we, what’s
our guess and what we expect to get from this state, and then our reward or our scaling
factor that we’re going to use to be pushing up or
down our probabilities, can now just be our expected
sum of future rewards, minus this baseline, so now
it’s the relative of how much better or worse is
the reward that we got from what we expected. And so how can we choose this baseline? Well, a very simple baseline, the
most simple you can use, is just taking a moving average of rewards that you’ve experienced so far. So you can even do this
overall trajectories, and this is just an
average of what rewards have I been seeing as I’ve been training, and as I’ve been playing these episodes? Right, and so this gives
some idea of whether the reward that I currently get
was relatively better or worse. And so there’s some variance
on this that you can use but so far the variance
reductions that we’ve seen so far are all used in what’s typically called “vanilla REINFORCE” algorithm. Right, so looking at the
cumulative future reward, having a discount factor,
and some simple baselines. Now let’s talk about how we can think about this idea of baseline and potentially choose better baselines. Right, so if we’re going to
think about what’s a better baseline that we can choose, what we want to do is we want
to push up the probability of an action from a state,
if the action was better than the expected value of what we
should get from that state. So, thinking about the value
of what we’re going to expect from the state, what
does this remind you of? Does this remind you of anything that we talked about
earlier in this lecture? Yes. [inaudible from audience] Yeah, so the value functions, right? The value functions that we
talked about with Q-learning. So, exactly. So Q-functions and value functions and so, the intuition is that well, we’re happy with an action, taking an action in a state s, if our Q-value of taking a specific action from
this state is larger than the value function or expected value of the cumulative future reward that we can get from this state. Right, so this means that
this action was better than other actions that we could’ve taken. And on the contrary, we’re
unhappy if this action, if this value or this
difference is negative or small. Right, so now if we plug
this in, in order to, as our scaling factor of how much we want to push up or down, our
probabilities of our actions, then we can get this estimator here. Right, so, it’s going to be exactly the same as before, but now where we’ve had before our
cumulative expected reward, with our various reduction,
variance reduction techniques and baselines in,
here we can just plug in now this difference of how much better our current action was,
based on our Q-function minus our value function from that state. Right, but what we talked
about so far with our REINFORCE algorithm, we don’t know what Q and V actually are. So can we learn these? And the answer is yes, using Q-learning. What we’ve already talked about before. So we can combine policy gradients while we’ve just been talking
about, with Q-learning, by training both an actor,
which is the policy, as well as a critic, right, a Q-function, which is going to tell us
how good we think a state is, and an action in a state. Right, so using this in approach, an actor is going to
decide which action to take and then the critic, or
Q-function, is going to tell the actor how good its action
was and how it should adjust. And so, and this also alleviates
a little bit of the task of this critic compared
to the Q-learning problems that we talked about earlier
of having to have this learning a Q-value for
every state, action pair, because here it only has to learn this for the state-action pairs that
are generated by the policy. It only needs to know this where it matters for
computing this scaling factor. Right, and then we can also,
as we’re learning this, incorporate all of the
Q-learning tricks that we saw earlier, such as experience replay. And so, now I’m also going to just define this term that we saw earlier, Q of s of a, how much,
how good was an action in a given state, minus V of s? Our expected value of
how good the state is by this term advantage function. Right, so the advantage
function is how much advantage did we get from playing this action? How much better the
action was than expected. So, using this, we can
put together our full actor-critic algorithm. And so what this looks like,
is that we’re going to start off with by initializing
our policy parameters theta, and our critic parameters
that we’ll call phi. And then for each, for
iterations of training, we’re going to sample M trajectories, under the current policy. Right, we’re going to play
our policy and get these trajectories as s-zero, a-zero,
r-zero, s-one and so on. Okay, and then we’re going to compute the gradients that we want. Right, so for each of these trajectories and in each time step, we’re going to compute this advantage function, and then we’re going to use this advantage function, right? And then we’re going to use
that in our gradient estimator that we showed earlier, and accumulate our gradient estimate that we have for here. And then we’re also going to train our critic parameters phi
by exactly the same way, so as we saw earlier,
basically trying to enforce this value function, right,
to learn our value function, which is going to be pulled
into, just minimizing this advantage function and this will encourage it to be closer
to this Bellman equation that we saw earlier, right? And so, this is basically
just iterating between learning and optimizing
our policy function, as well as our critic function. And so then we’re going to update the gradients and then we’re
going to go through and just continuously repeat this process. Okay, so now let’s look at
some examples of REINFORCE in action, and let’s look
first here at something called the Recurrent Attention Model,
which is something that, which is a model also
referred to as hard attention, but you’ll see a lot in,
recently, in computer vision tasks for various purposes. Right, and so the idea behind this is here, I’ve talked about the
original work on hard attention, which is on image
classification, and your goal is to still predict the image class, but now you’re going to do
this by taking a sequence of glimpses around the image. You’re going to look at local
regions around the image and you’re basically going
to selectively focus on these parts and build up information
as you’re looking around. Right, and so the reason
that we want to do this is, well, first of all it
has some nice inspiration from human perception in eye movement. Let’s say we’re looking at a complex image and we want to determine
what’s in the image. Well, you know, we might,
maybe look at a low-resolution of it first, and then
look specifically at parts of the image that will give us clues about what’s in this image. And then, this approach of just looking
at, looking around at an image at local regions, is also
going to help you save computational resources, right? You don’t need to process the full image. In practice, what usually
happens is you look at a low-resolution image
first, of a full image, to decide how to get started,
and then you look at high-res portions of the image after that. And so this saves a lot
of computational resources and you can think about,
then, benefits of this to scalability, right,
being able to, let’s say process larger images more efficiently. And then, finally, this
could also actually help with actual classification performance, because now you’re able to ignore clutter and irrelevant
parts of the image. Right? Like, you know, instead
of always putting through your ConvNet, all the parts of your image, you can use this to, maybe,
first prune out what are the relevant parts that I
actually want to process, using my ConvNet. Okay, so what’s the reinforcement learning formulation of this problem? Well, our state is going to be the glimpses that we’ve
seen so far, right? Our what’s the information that we’ve seen? Our action is then going to be where to look next in the image. Right, so in practice,
this can be something like the x, y-coordinates,
maybe centered around some fixed-sized glimpse that
you want to look at next. And then the reward for
the classification problem is going to be one, at
the final time step, if our image is correctly
classified, and zero otherwise. And so, because this glimpsing, taking these
glimpses around the image is a non-differentiable operation, this is why we need to use reinforcement learning formulation, and learn policies for how
to take these glimpse actions and we can train this using REINFORCE. So, given the state of glimpses so far, the core of our model is going to be this RNN that we’re going
to use to model the state, and then we’re going to
use our policy parameters in order to output the next action. Okay, so what this model looks
like is we’re going to take an input image. Right, and then we’re going to
take a glimpse at this image. So here, this glimpse is the red box here, and this is all blank, zeroes. And so we’ll pass what
we see so far into some neural network, and this can be any kind of network depending on your task. In the original experiments
that I’m showing here, on MNIST, this is very
simple, so you can just use a couple of small,
fully-connected layers, but you can imagine
for more complex images and other tasks you may want
to use fancier ConvNets. Right, so you’ve passed this
into some neural network, and then, remember I said
we’re also going to be integrating our state of,
glimpses that we’ve seen so far, using a recurrent network. So, I’m just going to we’ll see that later on, but
this is going to go through that, and then it’s going to output my x, y-coordinates, of where
I’m going to see next. And in practice, this is going to be We want to output a
distribution over actions, right, and so, what this is
going to be it’s going to be a gaussian distribution and
we’re going to output the mean. You can also output a mean and variance of this distribution in practice. The variance can also be fixed. Okay, so we’re going to take this action that we’re now going to sample a specific x, y location
from our action distribution and then we’re going to put
this in to get the next, extract the next glimpse from our image. Right, so here we’ve moved to the end of the two,
this tail part of the two. And so now we’re actually
starting to get some signal of what we want to see, right? Like, what we want to do is we
want to look at the relevant parts of the image that are
useful for classification. So we pass this through, again,
our neural network layers, and then also through our recurrent network, right,
that’s taking this input as well as this previous hidden
state, and we’re going to use this to get a, so this is representing our policy, and then we’re going to use this to output our distribution for the next location that we want to glimpse at. So we can continue doing this, you can see in this next glimpse here, we’ve moved a little bit more
toward the center of the two. Alright, so it’s probably learning that, you know, once I’ve seen
this tail part of the two, that looks like this,
maybe moving in this upper left-hand direction will
get you more towards a center, which will also have a value, valuable information. And then we can keep doing this. And then finally, at the
end, at our last time step, so we can have a fixed
number of time steps here, in practice something like six or eight. And then at the final time
step, since we want to do classification, we’ll have our standard Softmax layer that will produce a distribution of
probabilities for each class. And then here the max class was a two, so we can predict that this was a two. Right, and so this is going
to be the set up of our model and our policy, and then we have our estimate for the gradient
of this policy that we’ve said earlier we could compute by taking trajectories from here and using those to do back prop. And so we can just do this
in order to train this model and learn the parameters
of our policy, right? All of the weights that you can see here. Okay, so here’s an example of a policies trained on MNIST, and so you can see that, in general, from wherever it’s
starting, usually learns to go closer to where the digit is, and then looking at the relevant
parts of the digit, right? So this is pretty cool and this you know, follows kind of
what you would expect, right, if you were to choose places to look next in order to most efficiently determine what digit this is. Right, and so this idea of hard attention, of recurrent attention
models, has also been used in a lot of tasks in
computer vision in the last couple of years, so you’ll
see this, used, for example, fine-grained image recognition. So, I mentioned earlier that one of the useful benefits of this can be also to both save on computational efficiency as well as to ignore
clutter and irrelevant parts of the image, and
when you have fine-grained image classification problems, you usually want both of these. You want to keep high-resolution,
so that you can look at, you know, important differences. And then you also want to
focus on these differences and ignore irrelevant parts. Yeah, question. [inaudible question from audience] Okay, so yeah, so the question is how is there is
computational efficiency, because we also have this
recurrent neural network in place. So that’s true, it depends
on exactly what’s your, what is your problem, what
is your network, and so on, but you can imagine that
if you had some really hi- resolution image and you don’t want to process
the entire parts of this image with some huge ConvNet
or some huge, you know, network, now you can
get some savings by just focusing on specific
smaller parts of the image. You only process those parts of the image. But, you’re right, that
it depends on exactly what problem set-up you have. This has also been used
in image captioning, so if we’re going to produce
an caption for an image, we can choose, you know,
we can have the image use this attention model
to generate this caption and what it usually ends up
learning is these policies where it’ll focus on
specific parts of the image, in sequence, and as it
focuses on each part, it’ll generate some words
or the part of the caption referring to that part of the image. And then it’s also been used, also tasks such as visual
question answering, where we ask a question about the image and you want the model
to output some answer to your question, for
example, I don’t know, how many chairs are around the table? And so you can see how
this attention mechanism might be a good type of model for learning how to
answer these questions. Okay, so that was an
example of policy gradients in these hard attention models. And so, now I’m going to
talk about one more example, that also uses policy gradients, which is learning how to play Go. Right, so DeepMind had this agent for playing Go, called AlphGo, that’s been in the news a lot in the past, last year and this year. So, sorry? [inaudible comment from audience] And yesterday, yes, that’s correct. So this is very exciting,
recent news as well. So last year, a first version of AlphaGo was put into a competition against one
of the best Go players of recent years, Lee Sedol, and the agent was able to beat him four to one, in a game of five matches. And actually, right now, just there’s another match with
Ke Jie, which is current world number one, and
so it’s best of three in China right now. And so the first game was yesterday. AlphaGo won. I think it was by just
half a point, and so, so there’s two more games to watch. These are all live-stream, so you guys, should also go
online and watch these games. It’s pretty interesting
to hear the commentary. But, so what is this AlphaGo
agent, right, from DeepMind? And it’s based on a lot
of what we’ve talked about so far in this lecture. And what it is it’s a mixed
of supervised learning and reinforcement learning, as well as a mix of some older methods for Go, Monte Carlo Tree Search, as well as recent deep RL approaches. So, okay, so how does AlphaGo
beat the Go world champion? Well, what it first does is to train AlphaGo, what it
takes as input is going to be a few featurization of the board. So it’s basically, right,
your board and the positions of the pieces on the board. That’s your natural state representation. And what they do in order
to improve performance a little bit is that
they featurize this into some more channels of one is all
the different stone colors, so this is kind of like your configuration of your board. Also some channels, for
example, where, which moves are legal, some bias
channels, some various things and then, given this state, right, it’s going to first train a network that’s initialized with
supervised training from professional Go games. So, given the current board configuration or features, featurization of this, what’s the correct next action to take? Alright, so given examples of professional games played, you know, just collected over time, we can just take all of
these professional Go moves, train a standard, supervised mapping, from board state to action to take. Alright, so they take this,
which is a pretty good start, and then they’re going
to use this to initialize a policy network. Right, so policy network,
it’s just going to take the exact same structure of input is your board state and your output is the actions that you’re going to take. And this was the set-up
for the policy gradients that we just saw, right? So now we’re going to just
continue training this using policy gradients. And it’s going to do this
reinforcement learning training by playing against itself for
random, previous iterations. So self play, and the
reward it’s going to get is one, if it wins, and a
negative one if it loses. And what we’re also going to
do is we’re also going to learn a value network, so,
something like a critic. And then, the final AlphaGo
is going to be combining all of these together, so
policy and value networks as well as with a Monte Carlo Tree Search
algorithm, in order to select actions by look ahead search. Right, so after putting all this together, a value of a node, of
where you are in play, and what you do next, is
going to be a combination of your value function, as well as roll at outcome that you’re
computing from standard Monte Carlo Tree Search roll outs. Okay, so, yeah, so this is basically the various, the components of AlphaGo. If you’re interested in
reading more about this, there’s a nature paper about this in 2016, and they trained this, I think, over, the version of AlphaGo
that’s being used in these matches is, like, I think
a couple thousand CPUs plus a couple hundred GPUs,
putting all of this together, so it’s a huge amount of
training that’s going on, right. And yeah, so you guys should, follow the game this week. It’s pretty exciting. Okay, so in summary,
today we’ve talked about policy gradients, right,
which are general. They, you’re just directly taking gradient descent or
ascent on your policy parameters, so this works well for a
large class of problems, but it also suffers from high variance, so it requires a lot of samples, and your challenge here
is sample efficiency. We also talked about
Q-learning, which doesn’t always work, it’s harder to
sometimes get it to work because of this problem
that we talked earlier where you are trying to compute this exact state, action value for many, for very high
dimensions, but when it does work, for problems, for example,
the Atari we saw earlier, then it’s usually more sample efficient than policy gradients. Right, and one of the
challenges in Q-learning is that you want to make sure that you’re doing sufficient exploration. Yeah? [inaudible question from audience] Oh, so for Q-learning can
you do this process where you’re, okay, where you’re
trying to start this off by some supervised training? So, I guess the direct
approach for Q-learning doesn’t do that because you’re
trying to regress to these Q-values, right, instead of
policy gradients over this distribution, but I think there
are ways in which you can, like, massage this type of thing to also bootstrap. Because I think bootstrapping
in general or like behavior cloning is a good way to warm start these policies. Okay, so, right, so we’ve
talked about policy gradients and Q-learning, and just
another look at some of these, some of the guarantees that you have, right, with policy gradients. One thing we do know
that’s really nice is that this will always converge to
a local minimum of J of theta, because we’re just directly
doing gradient ascent, and so this is often, and this local minimum is
often just pretty good, right. And in Q-learning, on the
other hand, we don’t have any guarantees because here
we’re trying to approximate this Bellman equation with
a complicated function approximator and so, in this
case, this is the problem with Q-learning being a
little bit trickier to train in terms of applicability
to a wide range of problems. Alright, so today you got basically very, brief, kind of high-level
overview of reinforcement learning and some major classes
of algorithms in RL. And next time we’re going to have a guest lecturer from, Song
Han, who’s done a lot of pioneering work in model compression and energy efficient deep learning, and so he’s going to talk some
of this, about some of this. Thank you.