【深度强化学习】Q-learning 和 贝尔曼方程
文章目录
- 前言
- 第五章 Q-learning 和 贝尔曼方程
- 贝尔曼方程
- Value of Action 动作的价值
- 一个简单的例子
- 值迭代算法
- V值迭代算法
- Q值迭代算法
- 实例： FrozenLake中的值迭代算法
- collection.defaultdict
- 总结
前言
重读《Deep Reinforcemnet Learning Hands-on》， 常读常新， 极其深入浅出的一本深度强化学习教程。 本文的唯一贡献是对其进行了翻译和提炼， 加一点自己的理解组织成一篇中文笔记。
原英文书下载地址: 传送门
原代码地址： 传送门
终于安定下来了， 以后周末固定更新， 工作日随缘更新， 暑假结束前争取写完全书。
第五章 Q-learning 和 贝尔曼方程
其实原文的标题是 Tabular Learning， 但是读下来之后， 觉得其实就是 大名鼎鼎的 Q-learning， 因此以此作为本章的题目。 在前面的章节中，我们讨论了交叉熵方法，接下来的这部分， 我们要介绍更灵活且更强大的 Q-learning 方法。
第一章中，我们提到过一个强化学习中非常重要的概念： 状态的价值——the value of the state。 我们将其定义为：
V ( s ) = E [ ∑ t = 0 ∞ r t γ t ] V(s)=\mathbb{E}\left[\sum_{t=0}^{\infty} r_{t} \gamma^{t}\right] V(s)=E[t=0∑∞rtγt]，
其中 r t r_t rt是第t步时的reward。 γ \gamma γ则是折扣系数， 决定是否更在意当下reward还是长远。每个State的价值，应该和 采取的策略 紧密相连， 因为策略决定了后续步骤将到达的状态 s ( t ) s(t) s(t)和获得的奖励 r ( t ) r(t) r(t)。 举一个最简单的例子：
- 我们的初始状态是 1：start。
- 往右走到达终点状态2，并获得reward 1。
- 往下走到达终点状态3； 并获得reward 2。
这是一个确定的environment。 现在，我们的问题是， State 1 的 Value是多少？
考虑以下4种策略， 再基于 V ( s ) = E [ ∑ t = 0 ∞ r t γ t ] V(s)=\mathbb{E}\left[\sum_{t=0}^{\infty} r_{t} \gamma^{t}\right] V(s)=E[∑t=0∞rtγt]，有：
- Agent无脑往右， 到达状态2。 那么Value 就是 1.
- Agent无脑往下， 到达状态3。 那么Value 就是 2.
- Agent 有 50%的概率往右，50%概率往下。 根据Value的计算公式， 此时应该求取期望， 即 0.5 × 1 + 0.5 × 2 = 1.5 0.5\times 1 + 0.5 \times 2 = 1.5 0.5×1+0.5×2=1.5
- Agent 有 10%的概率往右，90%概率往下。 根据Value的计算公式， 此时应该求取期望， 即 1.5 × 1 + 0.9 × 2 = 1.9 1.5\times 1 + 0.9 \times 2 = 1.9 1.5×1+0.9×2=1.9
因此， 状态State的价值，与采取的策略直接挂钩。
那么，什么是这个环境的最佳策略？ 强化学习的目标就是最大化reward， 而本例中， reward等于状态1的Value（因为到达的下两个状态都是终止状态），所以最好的策略就是无脑往下。
显然，实际的问题往往不会这么简单。 不用担心， 我们将学会如果让Agent学习到最优的策略。
贝尔曼方程
理查德贝尔曼 (Richard Bellman)， 美国数学家， 提出了Q-learning的基石：贝尔曼方程。
我们首先考虑一个**确定性（deterministic）**环境， 即所有的动作都有确定的收益reward。假设在我们当前的State s 0 s_0 s0处， 共有 N N N个动作，依次对应下个状态 s 1 , s 2 , . . . s_1, s_2,... s1,s2,...， 获得的收益为 r 0 , r 1 , . . . r_0, r_1, ... r0,r1,...， 如图所示：
V 1 , V 2 , . . . V_1, V_2, ... V1,V2,...就是上一节讨论的 s 1 , s 2 s_1, s_2 s1,s2状态所对应的 Value。
令 V 0 V_0 V0代表我们想要探究的当前状态 s 0 s_0 s0的Value：
根据之前的公式： V 0 ( a = a i ) = E [ ∑ t = 0 ∞ r t γ t ] = E [ r t = 0 ] + E [ ∑ t = 1 ∞ r t γ t ] = r i + γ V i V_0(a=a_i)=\mathbb{E}\left[\sum_{t=0}^{\infty} r_{t} \gamma^{t}\right] =\mathbb{E}[ r_{t=0}] + \mathbb{E}\left[\sum_{t=1}^{\infty} r_{t} \gamma^{t}\right]=r_i+\gamma V_i V0(a=ai)=E[∑t=0∞rtγt]=E[rt=0]+E[∑t=1∞rtγt]=ri+γVi。
这个可能反而不太好理解：最简单的就直接直觉上理解：
当前状态下， 使用 a i a_i ai动作的价值 = 马上得到的价值(reward) + 下一个状态的价值。 因此， 假设我们的Agent足够优化， 我们肯定会选择最优的一个策略， 也就是说：
V 0 = max a ∈ 1 … N ( r a + γ V a ) V_{0}=\max _{a \in 1 \ldots N}\left(r_{a}+\gamma V_{a}\right) V0=a∈1…Nmax(ra+γVa)
这个很好理解： 就像我高考考了700分这个节点作为我当前的状态， 那我可以考虑采取的动作是 报考清华和复读一年。 前者的收益相当高——当时就得到了录取通知书( r a r_a ra)， 且到达一个极佳的状态(进入清华攻读)， 而后者的收益极低。 那么如何评估 高考考了700分 这个节点的价值呢？ 显然应该用优秀的动作 （报考清华） 的收益来衡量其价值。 这就是贝尔曼方程， 给出了我们对 状态价值 （the value of the state）的准确定义。
很容易地推广到随机性环境——同一个动作可能有概率得到不同的 r a r_a ra和 V a V_a Va， 那就应该通过期望来判定：
S S S代表 a a a动作可能得到的状态集合。 p a , 0 → s p_{a, 0\rightarrow s} pa,0→s代表转移概率。
这个方程看上去像作弊了：我们定义了一个东西， 却在定义中先用到了这个定义的东西 —— 我们在对State 0 V 0 V_0 V0 的价值的定义中，用到了对State s 的价值 V s V_s Vs 的定义。 然而这其实是一种广泛且通用的方法，如 动态规划， 数学归纳法中。 贝尔曼方程 不仅给出了我们所能得到的最大Reward， 也能给出最佳的策略（动作的选择）。
这本书这一部分讲的有点绕， 我总结一下，只需要记住这个方程就够了， 衡量State的价值：
V 0 = max a ∈ A E s ∼ S [ r s , a + γ V s ] = max a ∈ A ∑ s ∈ S p a , 0 → s ( r s , a + γ V s ) V_{0}=\max _{a \in A} \mathbb{E}_{s \sim S}\left[r_{s, a}+\gamma V_{s}\right]=\max _{a \in A} \sum_{s \in S} p_{a, 0 \rightarrow s}\left(r_{s, a}+\gamma V_{s}\right) V0=a∈AmaxEs∼S[rs,a+γVs]=a∈Amaxs∈S∑pa,0→s(rs,a+γVs)
Value of Action 动作的价值
为了让问题更简单， 我们可以定义除 V s V_s Vs外， 其他的度量： Q s , a Q_{s,a} Qs,a， 作为对在 s s s状态下选取 a a a动作时的策略评估。 简单而言， Q s , a Q_{s,a} Qs,a应当定于为在state s时执行动作 a a a时能获得的total reward。基于动作价值的方法， 就是大名鼎鼎的 Q-learning。
Q s , a Q_{s,a} Qs,a的定义基于我们刚刚对State Value的定义：
Q s , a = E s ′ ∼ S [ r s , a + γ V s ′ ] = ∑ s ′ ∈ S p a , s → s ′ ( r s , a + γ V s ′ ) Q_{s, a}=\mathbb{E}_{s^{\prime} \sim S}\left[r_{s, a}+\gamma V_{s^{\prime}}\right]=\sum_{s^{\prime} \in S} p_{a, s \rightarrow s^{\prime}}\left(r_{s, a}+\gamma V_{s^{\prime}}\right) Qs,a=Es′∼S[rs,a+γVs′]=s′∈S∑pa,s→s′(rs,a+γVs′)。
对比上一节中让大家记住的方程，显然有：
V s = max a ∈ A Q s , a V_{s}=\max _{a \in A} Q_{s, a} Vs=a∈AmaxQs,a
这就是上一节中说的——高考考700分这一状态的价值， 是取决于你最优的决策报考清华。
同样，我们也可以基于上面这个方程， 把 Q Q Q用自己来表示：
Q ( s , a ) = r s , a + γ max a ′ ∈ A Q ( s ′ , a ′ ) Q(s, a)=r_{s, a}+\gamma \max _{a^{\prime} \in A} Q\left(s^{\prime}, a^{\prime}\right) Q(s,a)=rs,a+γa′∈AmaxQ(s′,a′)
一个简单的例子
考虑上图这个环境——由于s1, s2, s3, s4都是终止状态，因此他们的价值等于0. 箭头线条旁标的是转移的概率。 如， 当选择 "up"动作时， 各有三分之一的概率到s1, s2, 和 s4状态。 由上一节定义的公式：
Q s , a = E s ′ ∼ S [ r s , a + γ V s ′ ] = ∑ s ′ ∈ S p a , s → s ′ ( r s , a + γ V s ′ ) Q_{s, a}=\mathbb{E}_{s^{\prime} \sim S}\left[r_{s, a}+\gamma V_{s^{\prime}}\right]=\sum_{s^{\prime} \in S} p_{a, s \rightarrow s^{\prime}}\left(r_{s, a}+\gamma V_{s^{\prime}}\right) Qs,a=Es′∼S[rs,a+γVs′]=s′∈S∑pa,s→s′(rs,a+γVs′)， 我们有：
Q s 0 , u p = 0.33 ∗ ( 1 + 0 ) + 0.33 ∗ ( 2 + 0 ) + 0.33 ∗ ( 4 + 0 ) = 2.31 Q_{s_0, up} =0.33 * (1+0) + 0.33 * (2 + 0) + 0.33 * (4 + 0) = 2.31 Qs0,up=0.33∗(1+0)+0.33∗(2+0)+0.33∗(4+0)=2.31
同理可以计算其他3个动作left, right, down的Q值。
如果我们拥有了准确的Q值， 策略就自然而生了——选择执行每个状态时对应Q值最大的动作即可。 然而，在实际中， 我们很难直接得到如此准确的概率及对应的reward， 以及状态转换的情况。 我们往往需要通过训练。从经验中学习。 下一节中， 我们会介绍一种Q value的迭代方法来解决之前提到的FrozenLake问题。
值迭代算法
所谓值迭代算法， 就是指，通过训练积累经验，再根据经验更新值（如Q值）， Q值随着训练愈发精确， 也就代表策略的愈发优秀。
V值迭代算法
- 初始化所有State的 V V V值为0
- 进行训练（随机和环境交互）， 根据环境返回的信息——S’, r, 使用贝尔曼方程更新 V V V值
V s ← max a ∑ s ′ p a , s → s ′ ( r s , a + γ V s ′ ) V_{s} \leftarrow \max _{a} \sum_{s^{\prime}} p_{a, s \rightarrow s^{\prime}}\left(r_{s, a}+\gamma V_{s^{\prime}}\right) Vs←amaxs′∑pa,s→s′(rs,a+γVs′) - 重复步骤2， 直到 V V V值的改变很小。
Q值迭代算法
- 初始化所有的动作Q值 Q s , a Q_{s,a} Qs,a
- 利用训练时的信息， 根据贝尔曼方程更新Q值
Q s , a ← ∑ s ′ p a , s → s ′ ( r s , a + γ max a ′ Q s ′ , a ′ ) Q_{s, a} \leftarrow \sum_{s^{\prime}} p_{a, s \rightarrow s^{\prime}}\left(r_{s, a}+\gamma \max _{a^{\prime}} Q_{s^{\prime}, a^{\prime}}\right) Qs,a←s′∑pa,s→s′(rs,a+γa′maxQs′,a′) - 重复步骤2， 直到收敛
两种方法中， V值迭代的话需要维护一张保存了所有S个状态value的表， 即一个 S × 1 S\times1 S×1的张量。 Q值迭代中则需要维护一张保存了所有S个状态下N个动作的Q值表， 即一个 S × Q S\times Q S×Q的张量（每个状态下有N个动作可选择）。实际践行策略时， 在s0状态时， V值迭代 会 遍历N个可选动作， 并计算各自的 r + V s r + V_s r+Vs， r r r是执行这个动作的当即收益， V s V_s Vs是执行后到达的状态，其Value可以直接读取（保存在维护的Value表格中）。然后，Agent选择值最大的一个动作执行。 Q值迭代就更简单了， 读取维护的Q值表格中， 代表了状态s0时所有动作Q值的那一行 ，选取Q值最大的一个动作执行， 即可。 两种方法本质上基本是完全一样的。
实例： FrozenLake中的值迭代算法
FrozenLake环境，在前一章中已介绍过， 不再赘述。 这里介绍使用值迭代法来解决。
书中选用的是V值迭代方法——后台维护一张表， 记录了所有状态的V值， 然后在训练中不断更新这张表， 最后用这张表来决定策略。
不多说了， 直接介绍代码。
import gym
import collections
from tensorboardX import SummaryWriter
ENV_NAME = "FrozenLake-v0"
GAMMA = 0.9
TEST_EPISODES = 20
一开始是简单的全局变量。TEST_EPISODES是用于评估Agent性能，所要进行的测试的游戏次数。
class Agent:
def __init__(self):
self.env = gym.make(ENV_NAME)
self.state = self.env.reset()
self.rewards = collections.defaultdict(float)
self.transits = collections.defaultdict(collections.Counter)
self.values = collections.defaultdict(float)
创建一个Agent类， 首先注意我们代码的核心思想，就在这个__init__初始化中。 **正如上面所说， 我们需要维护一张V值表。 但要想得到这个V值表，根据贝尔曼公式， 我们还需要知道每个动作对应的转换概率（用于计算期望值）。同时，由于我们最后根据V值表选取动作策略时， 还要考虑动作本身的当即reward，因此，也要维护一张reward表。 这个数据结构是理解算法的重点，这里重点介绍一下。
collection.defaultdict
作者使用了collection库的defaultdict类来建立数据结构。 这个类很容易理解，只有两点：
- 其他所有使用方法和普通的字典dict完全一样，也是key值和value值配对。
- 顾名思义， 可以指定字典的默认值。 如：
如果你访问普通字典（上例中的a）中的未定义的键值时， 会直接报KeyError错误。 但如果是defaultdict，会根据你一开始的参数(float)， 返回一个默认值。 如，我们在[27]中，把float作为输入的参数建立了一个defaultdict b， 那么当我们访问没有定义的b[0]时，会自动返回默认初始化值，float对应的是0.
这里先理解的话， 把defaultdict看做普通的dict看即可。
然后注意到，self.transits 的defaultdict的默认参数是 collections.Counter， 这个类可以这样理解： 就是一个字典， 键任意，值是一个整数。 这个类经常用于统计词频——键是词语本身， 值是该词出现的次数。 在本例中， 键是状态， 值是出现的次数。 通过训练中，各个状态之间转换的次数统计， 我们可以算出频率， 也就对应于我们想要获得的转换概率，用以计算V值。
我们再结合下一段代码，来理解Agent中维护的这三个表的意义：
def play_n_random_steps(self, count):
for _ in range(count):
action = self.env.action_space.sample()
new_state, reward, is_done, _ = self.env.step(action)
self.rewards[(self.state, action, new_state)] = reward
self.transits[(self.state, action)][new_state] += 1
self.state = self.env.reset() if is_done else new_state
这一段，就是我们之前提到的进行训练（本质上是随机玩游戏），再通过积累的经验更新表格。
self.rewards这个字典（其实是defaultdict），键值是(当前状态， 动作， 新状态)， 值是这一转换——通过执行该动作从当前状态转换到新状态的reward。
同理， self.transits里储存的格式为：
可以理解为字典的字典。 其中，键值是当前的状态和执行的动作， 值是一个字典， 该字典的键是每个可能达到的下一状态， 值是 出现的次数。 比如上图中，第一项代表的是 —— 在0状态时，执行动作2后的 情况—— 达到1状态11次， 达到4状态6次， 保持在0状态5次。 通过这个数据，我们就可以粗略地计算一个转移概率了。
上图是一个简单的释义——如何通过维护的transit表格， 计算Q值和V值。
接下来， 我们再给出一个计算动作Q值的代码——这不仅在执行策略时需要用到， 也会用于维护V值表（V值相当于当前状态所有动作Q值的最大值）
def calc_action_value(self, state, action):
target_counts = self.transits[(state, action)]
total = sum(target_counts.values())
action_value = 0.0
for tgt_state, count in target_counts.items():
reward = self.rewards[(state, action, tgt_state)]
action_value += (count / total) * (reward + GAMMA * self.values[tgt_state])
return action_value
因为我们有一张维护的V值表， 所以Q值的计算只需要由我们维护的reward表中的reward 加上到达状态的V值就行了。 由于到达的状态也有随机性， 因此， 我们需要计算期望。
然后， 我们就拥有了根据训练经验来更新表的能力，由以下代码实现：
def value_iteration(self):
for state in range(self.env.observation_space.n):
state_values = [self.calc_action_value(state, action)
for action in range(self.env.action_space.n)]
self.values[state] = max(state_values)
遍历所有可能的状态， 每个状态的值，用公式 V s = max a ∈ A Q s , a V_{s}=\max _{a \in A} Q_{s, a} Vs=maxa∈AQs,a 来计算V值进行更新即可，Q值则用刚刚的计算函数计算即可。
最后，写一个测试函数，用于评估策略性能：
def select_action(self, state):
best_action, best_value = None, None
for action in range(self.env.action_space.n):
action_value = self.calc_action_value(state, action)
if best_value is None or best_value < action_value:
best_value = action_value
best_action = action
return best_action
def play_episode(self, env):
total_reward = 0.0
state = env.reset()
while True:
action = self.select_action(state)
new_state, reward, is_done, _ = env.step(action)
self.rewards[(state, action, new_state)] = reward
self.transits[(state, action)][new_state] += 1
total_reward += reward
if is_done:
break
state = new_state
return total_reward
我们的策略就是， 计算每个动作的Q值， 然后选择其中最大的一个执行。 最后的total reward用于评估当前Agent的性能。
最后，运行程序。 每次由于随机性， 结果会有一定的偏差。
总结
方法的核心就是用贝尔曼公式， 利用训练时的积累经验，不断更新V值和Q值， 最后Agent采取的策略就是利用维护的V值或Q值表， 选择Q值最大的动作执行。 其中巧妙的就是，每个V值定义在下一状态的V值之后， 类似于数学归纳法和动态规划的思想，可以有效解决问题。这也是DQN的核心 这样的递归定义可以有效的解决这种问题。