Add files via upload
This commit is contained in:
Yiyuan Yang
@@ -0,0 +1,238 @@
|
||||
# Deep Recurrent Q-Learning for Partially Observable MDPs（部分可观测马尔可夫决策过程的深度循环Q学习）
|
||||
作者：Matthew Hausknecht，Peter Stone <br>
|
||||
单位：Department of Computer Science The University of Texas at Austin <br>
|
||||
论文发表会议：National conference on artificial intelligence <br>
|
||||
论文发表时间：Submitted on 23 Jul 2015, last revised 11 Jan 2017 <br>
|
||||
论文查看网址：https://arxiv.org/abs/1507.06527
|
||||
|
||||
论文贡献：提出一种基于DQN的神经网络模型（DRQN），将包含卷积神经网络（CNN）的DQN模型和LSTM结合，使强化学习智能体拥有记忆力的特性。
|
||||
|
||||
## 一. 写作动机
|
||||
<font size="4">**Why:**</font> <br>
|
||||
在<font color="#660000"> *Playing Atari with Deep Reinforcement Learning(Mnih et al., 2013)* </font>中，DQN是使用智能体（Agent）遇到的包含当前状态的最后4个状态的组成（最后4个画面）作为**输入**。**目的**是获得画面中物体/角色的<font color="#0000dd">**方向**、**速度**</font>等信息。但换句话说，倘若遇到需要记忆特征超过四个画面的时间跨度任务时，对于DQN来说，则会由马尔可夫决策过程（MDP）变成部分可观测的马尔可夫决策过程（POMDP）。
|
||||
|
||||
<font size="4">**What:**</font> <br>
|
||||
部分可观测的马尔可夫决策过程（Partially-Observable Markov Decision Process, POMDP）是指：当前观测（Observation，obs）的不完整且带有噪音，不包含环境运作的所有状态。导致无法作为环境（Environment，env）的完整描述信息（智能体得到观测跟环境的状态不等价）。
|
||||
|
||||
<font size="4">**How:**</font> <br>
|
||||
论文作者提出，为避免因部分可观测的马尔可夫决策过程（POMDP）导致DQN在任务环境学习的过程中出现性能下降，引入**Deep Recurrent Q-Network (DRQN)**，是基于LSTM（Long Short-Term Memory，LSTM）和DQN的组合。并**证明使用DRQN能有效处理部分可观测的马尔可夫决策过程（POMDP）**，当评估智能体时，输入智能体的观测（obs）发生变化（遮盖、画面闪烁）时，因参数化价值函数（Value function）包含循环神经网络层（LSTM）能够使学习到的 策略$\pi_{\theta }$ 具有鲁棒性，不会发生策略崩塌。
|
||||
|
||||
## 二. 背景介绍
|
||||
### 1. Deep Q-Learning（深度Q学习）
|
||||
使用深度Q学习方法，是通过参数为$\theta$的深度神经网络来近似价值函数（Value Function）$V(s)$或动作价值函数（Action-Value Function）$Q(s,a)$来隐式的学习最优策略$\pi ^*$，输入环境的观测（obs），输出对观测（obs）估计的V值或Q值。
|
||||
|
||||
深度Q学习适用场景：连续状态空间（State space）离散动作空间（Action Space）任务。
|
||||
|
||||
价值函数的作用为：评估在当前状态-动作下，未来回报（Return）的期望。
|
||||
|
||||
使用深度神经网络作为强化学习的参数化值函数近似器的优点： <br>
|
||||
（1）具有深度学习自动提取特征的能力。 <br>
|
||||
（2）参数化模型将现有可见的观测（obs）泛化到没有见过的观测（obs）：$|\theta|\ll|S\times A|$ <br>
|
||||
（3）参数化模型可通过求导数的形式来更新神经网络模型参数。
|
||||
|
||||
参数化价值函数为：
|
||||
|
||||
$$V_\theta (s)\cong V^\pi (s) \\ Q_\theta (s,a)\cong Q^\pi (s,a)$$
|
||||
|
||||
深度Q学习保持学习稳定的技巧（Trick）： <br>
|
||||
（1）经验回放（Experience Replay）：针对数据层面的相关性和数据分布变化做改进，使得数据尽可能满足独立同分布（i.d.d）属性。 <br>
|
||||
（2）目标网络（Target Network）：解决在时序差分（Timing Difference，TD）学习时，TD target和当前Q网络高度相关的问题。
|
||||
|
||||
深度Q学习的损失函数（Loss Function）为：
|
||||
|
||||
$$\mathcal{L}_{i}\left(\theta_{i}\right)=\mathbb{E}_{\left(s, a, r, s^{\prime}\right) \sim \mathcal{D}}\left[\left(y_{i}-Q\left(s, a ; \theta_{i}\right)\right)^{2}\right] \\
|
||||
y_{i}=r+\gamma \max _{a^{\prime}} \hat{Q}\left(s^{\prime}, a^{\prime} ; \theta^{-}\right)
|
||||
$$
|
||||
深度Q学习的最优动作$a^*$为当前状态（state）下价值函数输出Q值最大对应的动作：
|
||||
$$
|
||||
a=arg\;\underset{a}{max} Q(s,a)
|
||||
$$
|
||||
### 2. Partial Observability（部分可观测）
|
||||
马尔可夫决策过程（MDP）五元组（S，A，P，$\gamma$，R）： <br>
|
||||
（1）S是状态的集合 <br>
|
||||
（2）A是动作的集合 <br>
|
||||
（3）$P(s'|s,a)$是环境的状态转移概率 <br>
|
||||
（4）$\gamma \in [0,1]$是对未来累积奖励（回报 Return）的折扣因子 <br>
|
||||
（5）R是奖励函数，R:S × A
|
||||
|
||||
部分可观测的马尔可夫决策过程（POMDP）七元组（S，A，P，$\gamma$，R，Ω，O）： <br>
|
||||
（1）Ω是观测$(obs,o)$的集合， $o\in \Omega$ <br>
|
||||
（2）O是观测函数，$O(s',a,o)= P(o | s',a)$
|
||||
|
||||
因为观测（obs）是对状态的部分描述，所以可能会遗漏一些信息。
|
||||
$$Q(o, a \mid \theta) \neq Q(s, a \mid \theta)$$
|
||||
|
||||
论文作者通过实验证明，使用DRQN可以缩小价值函数对于观测（obs）的Q值与对状态（State）的Q值之间的差距。即智能体学习到的策略能在具有POMDP性质的任务环境中具有鲁棒性。
|
||||
|
||||
## 三. 模型架构
|
||||
 <br>
|
||||
**模型输入**：Atari 游戏的84*84像素的单通道图像 <br>
|
||||
**模型输出**：游戏对应18个离散动作的Q值
|
||||
|
||||
模型架构解释： <br>
|
||||
①首先使用3层卷积神经网络（Convolutional Neural Networks，CNN）提取图像特征。 <br>
|
||||
②其次传入LSTM，获得游戏画面之间的序列特征。 <br>
|
||||
③最后使用全连接层（Fully Connected Layers，FC）变成Q值。
|
||||
|
||||
## 四. 智能体更新方法
|
||||
**Bootstrapped Random Updates**：从经验池（Replay Memory）中随机选择一个回合的轨迹$\tau$ ，并从该回合的经验片段中随机选择开始点沿时间步骤顺序更新模型。（以时序差分Timing Difference的方式更新）
|
||||
|
||||
$$\tau =\left \{ s_0, a_0, s_1, r_1, a_1, \cdots ,s_{t-1}, r_{t-1}, a_{t-1}, s_t, r_t\right \} $$
|
||||
|
||||
例如：选择从轨迹$\tau$的$s_2$进行顺序更新，直到轨迹$\tau$的终止状态$s_t$停止。
|
||||
|
||||
设计缺陷：使用随机更新方式符合DQN中随机采样经验的更新策略。但在本论文的价值函数设计中包含LSTM层。导致在每次训练更新开始时，**LSTM**会因为 **隐含状态$h_{t-1}$** 的输入为零，导致LSTM难以学习比时间序列反向传播到达的时间步骤更长的时间范围。
|
||||
|
||||
**LSTM**结构图：
|
||||
|
||||
|
||||
|
||||
遗忘门（Forget Gate）：控制哪些数据保留，哪些数据要遗忘。 <br>
|
||||
输入门（Input Gate）：控制网络输入数据流入记忆单元的多少。 <br>
|
||||
输出门（Output Gate）：扛着记忆但与对当前输出数据的影响，即记忆单元中的哪一部分会在时间步t输出。 <br>
|
||||
细胞状态（Cell State）：将旧的细胞状态更新为当前细胞状态，由遗忘门和输入门共同控制。
|
||||
|
||||
本文使用的智能体的更新方式均为**随机更新策略**。
|
||||
|
||||
## 五. 任务环境
|
||||
本文选择9个Atari 2600游戏任务环境进行评估基于DRQN神经网络模型的智能体(Agent)性能。
|
||||
|
||||
游戏环境示意图为：
|
||||
|
||||
|
||||
|
||||
|游戏环境 | 介绍 |
|
||||
|--|--|
|
||||
|Asteroids |具有自然闪烁的NPC，使其成为潜在的循环学习候选 |
|
||||
| Ms Pacman | 通关类游戏，有闪烁的幽灵和强力药丸 |
|
||||
|Frostbite|平台类游戏|
|
||||
| Beam Rider | 射击类游戏 |
|
||||
| Centipede | 射击类游戏 |
|
||||
| Chopper Command | 射击类游戏 |
|
||||
|Ice Hockey|体育比赛类|
|
||||
|Double Dunk|体育比赛类|
|
||||
|Bowling|体育比赛类|
|
||||
|
||||
|
||||
- [Atari 2600在线游戏网页](https://www.free80sarcade.com/all2600games.php)
|
||||
|
||||
## 六. 损失函数与奖励函数
|
||||
**损失函数**（Loss Function）：论文作者主要提出基于DRQN的神经网络模型，没有对DQN的强化学习算法进行更改，仍然采用DQN的损失函数进行神经网络模型拟合（动作价值函数，Action-Value Function）。
|
||||
$$\mathcal{L}_{i}\left(\theta_{i}\right)=\mathbb{E}_{\left(s, a, r, s^{\prime}\right) \sim \mathcal{D}}\left[\left(y_{i}-Q\left(s, a ; \theta_{i}\right)\right)^{2}\right] \\
|
||||
y_{i}=r+\gamma \max _{a^{\prime}} \hat{Q}\left(s^{\prime}, a^{\prime} ; \theta^{-}\right)
|
||||
$$
|
||||
|
||||
**奖励函数**（Reward Function）：论文使用的任务环境为Atari 2600游戏环境，根据不同的游戏任务，环境都自带奖励函数，不需要额外定义。
|
||||
|
||||
## 七. 实验证明
|
||||
### 1. Flickering Pong POMDP（闪烁的Pong，部分可观测马尔可夫决策过程）
|
||||
DQN通过输入包含当前观测（obs）的最后四个画面来实现将部分可观测的马尔可夫决策过程（POMDP）转换成为马尔可夫决策过程（MDP）。
|
||||
|
||||
**实验目的**：而为了验证DRQN在具有POMDP性质的游戏环境中对连续的模糊输入具有鲁棒性。引入<font color="##00dd00"> **Flickering Pong POMDP** </font>对Pong游戏的修改。
|
||||
|
||||
|
||||
|
||||
**实验设计**：在每个时间步长，游戏画面完全显示或完全模糊的概率 **$p=0.5$**。使用这种方式使 Flickering Pong 游戏环境 有一半的概率，画面被模糊化，使智能体得到观测（obs）具有POMDP性质。
|
||||
为了验证 ：
|
||||
①DQN神经网络模型中卷积层（CNN）能够具有在模糊观测画面中检测物体移动 **速度、方向** 的能力，在Flickering Pong游戏环境中输入包含当前观测画面的最后10个画面到模型中，并以可视化方式确认。
|
||||
②DRQN神经网络模型中LSTM层具有在模糊观测画面中检测物体历史特征，在Flickering Pong游戏环境中输入当前观测画面到模型中，并以可视化方式确认。
|
||||
|
||||
**实验baseline**：DQN神经网络模型（输入包含当前观测画面的**最后10个画面**）。
|
||||
|
||||
|
||||
现象：在第一层卷积层中，滤波器主要检测到 Flickering Pong游戏环境 中的**球拍**。
|
||||
|
||||
|
||||
|
||||
现象：在第二层卷积层中，滤波器开始检测到 Flickering Pong游戏环境 中的**球拍**以及**球**的运动方向，有的状态下滤波器也能同时检测到**球拍、球**。
|
||||
|
||||
|
||||
|
||||
现象：在第三层卷积层中，滤波器都能检测到**球拍**和**球**的相互作用，有偏转、球的速度和移动方向。
|
||||
|
||||
**实验**：为了验证DRQN神经网络模型中LSTM层能够检测到画面与画面间的序列特征，在每个时间步内仅输入当前观测（obs）到的**1个画面**到DRQN模型中。
|
||||
|
||||
|
||||
现象：LSTM层各单元能够透过具有闪烁的单个观测画面，检测到Flickering Pong游戏环境中的高级事件，例如**球从墙上反弹**等。
|
||||
|
||||
**实验结论**：通过 **输入10个连续观测画面到含有卷积层的DQN** 以及 **输入1个观测画面到含有LSTM层的DRQN** 进行对比，结果显示都能检测到游戏画面的历史特征。基于此，当任务环境具有POMDP性质时，上述两种方法都可供选择。证明**使用LSTM神经网络层，能够在具有时间序列特征的单个观测画面中整合序列特征**。
|
||||
|
||||
### 2. Evaluation on Standard Atari Games （标准的Atari游戏评估）
|
||||
**实验目的**：为了对比论文作者提出的DRQN神经网络模型和基于卷积神经网络（CNN）的DQN神经网络模型在标准的Atari 2600游戏任务环境中的表现，使用9个不同的 Atari 2600 游戏环境进行综合评估。
|
||||
|
||||
**实验设计**：为了让任务符合MDP性质，设置输入为包含当前观测画面的最后4个画面。并使用 **独立 t 检验** 计算得分的统计显著性，显著性水平$P=0.05$
|
||||
|
||||
**实验baseline**：基于卷积神经网络（CNN）的DQN神经网络模型在9个标准的Atari 2600游戏任务环境中的表现。
|
||||
|
||||
|
||||
|
||||
**实验结论1**：在9个不同的游戏任务环境中，基于DRQN神经网络模型的智能体得分在5个环境上的表现优于基于DQN神经网络模型的智能体。
|
||||
|
||||
|
||||
|
||||
**实验结论2**：DRQN在Beam Rider游戏中表现相比DQN明显更差。
|
||||
|
||||
<font color="#dd00dd">*个人分析*</font> ：可能是Beam Rider游戏中的**决策依据**并不需要时间跨度太久远的观测画面特征，主要依于当前即时观测画面的特征。加入的LSTM层反而导入过多不必要的特征造成智能体决策上的干扰。
|
||||
|
||||
|
||||
|
||||
**实验结论3**：DRQN在 Frostbite游戏 中表现最好。游戏的任务是要求玩家跳过所有四排移动的冰山并返回屏幕顶部。多次穿越冰山后，已经收集到足够的冰块，可以在屏幕右上角建造一个冰屋。随后玩家可以进入冰屋进入下一关。
|
||||
|
||||
<font color="#dd00dd">*个人分析*</font>： Frostbite游戏任务 具有长时间跨度决策性质，因此DRQN的LSTM层能够学习到具有长时间跨度的特征，智能体决策上的依据能够超越输入模型的4个观测画面所具有的特征。
|
||||
|
||||
### 3. MDP to POMDP Generalization（MDP到POMDP的泛化性）
|
||||
**实验目的**：为了评估使用基于DRQN模型的智能体在标准的MDP（输入为包含当前观测画面的最后4个画面）上训练得到的策略$\pi$，在推广到POMDP性质的相同游戏任务环境时，智能体的策略$\pi$能否保持有效性？
|
||||
|
||||
**实验设计**：选择用实验2的9个Atari 2600游戏任务环境进行闪烁（Flickering）设置，在每个时间步长，游戏画面完全显示的概率$p$按照0.1~0.9的概率依次使用训练好的智能体进行实验。
|
||||
|
||||
**实验baseline**：基于卷积神经网络（CNN）的DQN神经网络模型在POMDP性质的Atari 2600 游戏任务环境中的百分比原始分数（Percentage Original Score）。
|
||||
|
||||
|
||||
|
||||
**实验结论**：在标准的MDP训练的基于DRQN模型的智能体和基于DQN模型的智能体，分别在闪烁（Flickering）设置的游戏环境中进行评估，通过折线图观察到，基于DRQN模型的智能体性能下降的幅度相比基于DQN模型的智能体更小。
|
||||
$$Percentage\,Original\,Score=\frac{ {\textstyle \sum_{i=1}^{9}}POMDP\,Score }{ {\textstyle \sum_{i=1}^{9}}MDP\,Score } \\
|
||||
i\ is\ the\ number\ of\ game\ environments$$
|
||||
|
||||
## 八. 相关工作
|
||||
### 1. LSTM在解决具有POMDP性质的任务上相比于RNN的优越性
|
||||
在<font color="#660000"> *Reinforcement learning with long shortterm memory(Bakker et al., 2001)* </font>这篇论文中，在具有POMDP性质的Corridor和Cartpole环境上，使用LSTM神经网络作为强化学习中的 优势函数（Advantage Function）近似，相比于使用RNN神经网络能够更好的完成任务。虽然Corridor和Cartpole环境的状态空间特征数量以及动作空间，相比于Atari 2600 游戏环境都很少！
|
||||
|
||||
### 2. LSTM在解决具有POMDP性质的任务框架
|
||||
在<font color="#660000"> *Solving deep memory POMDPs with recurrent policy gradients(Wierstra et al., 2007)* </font>这篇论文首先使用策略梯度（Policy Gradient）结合LSTM神经网络解决具有POMDP性质的问题。但模型在特征提取上属于手工设计的特征，并没有结合深度神经网络模型做到自动提取特征。
|
||||
|
||||
## 九. 结论
|
||||
1. 基于DRQN模型的智能体在 POMDP性质的 Atari 2600 游戏环境下处理观测（obs）时，能够利用单个观测画面的输入，达到与基于DQN模型的智能体在输入连续10个观测画面得到的历史特征相同。即使用基于DRQN模型能够降低计算复杂度。
|
||||
2. 根据 标准的 Atari 2600 游戏环境的任务属性不同，在需要接收长时间跨度特征的任务中（例如 Frostbite 游戏），基于DRQN模型的智能体的表现会远超于基于DQN模型的智能体。
|
||||
3. 基于DRQN模型的智能体在相同的 Atari 2600 游戏环境下遇到出现POMDP的情况下，其泛化性会比基于DRQN模型的智能体好。
|
||||
|
||||
## 十. 贡献
|
||||
本文通过实验证明，加入 **LSTM神经网络** 的DRQN模型的智能体，面对具有POMDP性质的问题上，其性能表现优于DQN。但在实践过程中，仍需以任务的实际情况而定。通用性不高，并无法带来系统性的提升。
|
||||
|
||||
## 十一. 下一步的工作
|
||||
### 1. 强化学习算法层面
|
||||
在连续状态空间、离散动作空间的任务中，有结合**Double DQN**和**Dueling DQN**的**D3QN算法**。可以在本论文提出的DRQN神经网络模型架构上，使用D3QN强化学习算法来进行实验，观察智能体在本次论文的实验中表现不好的任务环境（例如 Beam Rider 游戏）是否能够得到性能上的提高，并达到系统性的提升。
|
||||
|
||||
### 2. 任务环境层面
|
||||
在强化学习机器控制领域上的任务情境中，智能体不仅需要对环境输出的观测（obs）学习时间序列特征，还需要将智能体本身输出的动作（Action）纳入成为观测的一部分进行学习。期待之后智能体训练好的 **策略$\pi$** 既能够对环境输出的观测进行考量，也能将历史动作纳入考虑的范围，以输出连贯合理的决策动作。
|
||||
|
||||
|
||||
### 3. 深度神经网络模型层面
|
||||
随着自注意力机制为核心的Transformer神经网络模型的出现，Transformer抛弃传统的CNN和RNN，只使用注意力机制（Attention）。同时Vision Transformer的出现打破了NLP领域和CV领域的边界，以Transformer为代表的决策模型成为当前RL领域的新范式。
|
||||
那么是否在同样是以图像作为观测的 Atari 2600 游戏任务环境上，以DQN算法为基础，使用 **基于Vision Transformer模型** 拟合价值函数，来隐式的学习策略$\pi$，以期望在智能体能够达到更好的性能！
|
||||
|
||||
|
||||
## 参考文献
|
||||
1. Volodymyr Mnih, J. et al. 2013. Playing Atari with Deep Reinforcement Learning.
|
||||
2. Wierstra, D.; Foerster, A.; Peters, J.; and Schmidthuber, J. 2007. Solving deep memory POMDPs with recurrent policy gradients.
|
||||
3. Bakker, B. 2001. Reinforcement learning with long shortterm memory. In NIPS, 1475–1482. MIT Press.
|
||||
4. [推荐中的序列化建模：Session-based neural recommendation](https://zhuanlan.zhihu.com/p/30720579)
|
||||
5. [论文十问-快速理解论文主旨的框架](https://www.cnblogs.com/xuyaowen/p/raad-paper.html)
|
||||
6. [RLChina 2022 强化学习暑期课](http://rlchina.org/topic/491)
|
||||
7. [蘑菇书EasyRL](https://github.com/datawhalechina/easy-rl)
|
||||
|
||||
====================================<br>
|
||||
作者：林俊杰<br>
|
||||
研究单位：台湾成功大学制造资讯与系统研究所<br>
|
||||
研究方向：强化学习、深度学习<br>
|
||||
联系邮箱：554317150@qq.com
|
||||
|
||||
224
papers/DQN/Deep Reinforcement Learning with Double Q-learning.md
Normal file
224
papers/DQN/Deep Reinforcement Learning with Double Q-learning.md
Normal file
@@ -0,0 +1,224 @@
|
||||
# Deep Reinforcement Learning with Double Q-Learning 论文剖析
|
||||
|
||||
Hado van Hasselt 、Arthur Guez 、 David Silver from Google DeepMind
|
||||
|
||||
## 〇. 文章信息
|
||||
|
||||
**Deep Reinforcement Learning with Double Q-learning**
|
||||
|
||||
作者：Hado van Hasselt 、Arthur Guez 、 David Silver from Google DeepMind ,2015
|
||||
|
||||
https://arxiv.org/abs/1509.06461
|
||||
|
||||
|
||||
|
||||
## 一. 写作动机
|
||||
|
||||
高估问题（overestimation）一直是强化学习中存在的问题，但是一直以来其来源有多种说法，一是归因于不灵活的函数近似（Thrun和Schwartz, 1993），一是来自噪声（van Hasselt, 2010, 2011）。通过实验也表明，高估问题的普遍性相较之前认识的要普遍的多，需要找到方法缓解其影响。
|
||||
|
||||
本文的写作动机就是探索高估的产生，验证高估问题对于Q-Learning是否不利，并寻找缓解高估问题的方法。
|
||||
|
||||
|
||||
|
||||
## 二 . Q-Learning算法的进化历史
|
||||
|
||||
本文中，作者总结了DQN的发展：
|
||||
|
||||
### 1. Q-Learning——解决时序决策问题的方法
|
||||
|
||||
Q-Learning是一种**时序差分方法**，很好的被用在时序决策问题中(Watkins, 1989)，其通过估计最优动作价值函数$$ Q_{\pi}(s,a)=\mathbb{E}[R_1+\gamma R_2+...|S_0=s, A_0=a,\pi],$$ 并对每个状态选择最优的动作价值函数所对应的动作，从而间接生成最优策略。
|
||||
|
||||
具体请参考Q-Learning文章，此处给出迭代公式方便后续说明。
|
||||
|
||||
$$ Q(S_t,A_t)=Q(S_t,A_t)+ \alpha (Y_t^Q-Q(S_t,A_t)) \tag{1} $$
|
||||
|
||||
### 2. 价值函数拟合的Q-Learning
|
||||
|
||||
因为状态过多或者连续，无法遍历所有状态，需要使用参数化函数$ Q(s,a;\theta _t)$对现有值进行拟合，并对未知状态的价值函数进行预测，通过公式
|
||||
|
||||
$$\theta_{t-1}=\theta_t +\alpha(Y_t^Q-Q(S_t,A_t;\theta_t))\nabla Q(S_t, A_t,;\theta _t) \tag{2} $$
|
||||
|
||||
完成参数更新，其中$Y_t^Q =R_{t+1}+\gamma \substack{max\\a}Q(S_{t+1},a;\theta _t)$是TD-target, 主要思想就是使用类似梯度下降的方法，使得拟合出的参数化函数更加接近目标，也就是说更加符合真实值。
|
||||
|
||||
解决了传统Q-Learning中的无法解决的**未知状态**问题，即欠鲁棒的问题。
|
||||
|
||||
### 3.Deep Q Networks（DQN）
|
||||
|
||||
（Mnih et al. ,2015)）——神经网络+Q-Learning
|
||||
|
||||
说到函数拟合就不得不提到神经网络，它具有极强的**函数拟合**能力，DQN应运而生。
|
||||
|
||||
DQN针对传统Q-Learning有以下三点改进，提高了算法的性能：
|
||||
|
||||
1. #### 使用神经网络来代替参数化函数,增强了函数拟合能力
|
||||
|
||||
2. #### 使用目标网络
|
||||
|
||||
使用一个异步更新的目标网络,网络参数用$\theta^-$表示（每$\tau$次将Q-net的参数$\theta$赋值给目标网络）用来进行目标的计算。
|
||||
|
||||
$$Y_t^Q = R_{t+1}+\gamma\substack{max\\a}Q(S_t=s, A_t=a;\theta^-_t) \tag{3} $$
|
||||
|
||||
|
||||
|
||||
3. #### 使用**经验回放**(Lin, 1992)：储存经验并重复使用，增加了利用率，减少采样成本
|
||||
|
||||
4. #### Double DQN
|
||||
|
||||
本文的重点，下一章介绍
|
||||
|
||||
|
||||
|
||||
## 三 . Double DQN
|
||||
|
||||
### 1. 具体操作
|
||||
|
||||
更换计算目标的方式，公式为：
|
||||
|
||||
$$Y_t^Q = R_{t+1}+\gamma Q(S_t=s, A_t=\substack{argmax\\{a \in \mathbb{A}}}Q(s,a|\theta_t^-);\theta_t) \tag{4} $$
|
||||
|
||||
### 2. 思想来源：解耦选取与计算
|
||||
|
||||
在传统DQN中,TD-target的计算可以分为两个步骤：**最优动作的选取** 与 **最优动作价值函数的计算** 。该公式可以变形为以下分解形式:
|
||||
|
||||
$$ a^*=\substack{argmax\\{a \in \mathbb{A}}}Q(s,a|\theta_t)\\Y_t^Q=r+\gamma Q(S_t=s, A_t=a^*;\theta_t)$$
|
||||
|
||||
计算目标的任务就转换到了目标网络上：
|
||||
|
||||
$$
|
||||
a^*=\substack{argmax\\{a \in \mathbb{A}}}Q(s,a|\theta_t^-)\\Y_t^Q=r+\gamma Q(S_t=s, A_t=a^*;\theta_t^-)
|
||||
$$
|
||||
使用上面提到的Double Q-Learning，则变为以下形式：
|
||||
|
||||
$$ a^*=\substack{argmax\\{a \in \mathbb{A}}}Q(s,a|\theta_t^-)\\Y_t^Q=r+\gamma Q(S_t=s, A_t=a^*;\theta_t)$$
|
||||
|
||||
***其实Q-Learning也有Double的形式，分别训练两个模型$\theta$,$\theta'$ 操作一样，只是这里Double DQN巧妙地使用了目标网络$\theta^-$ 作为第二个网络***
|
||||
|
||||
为了方便观看，使用表格形式展示
|
||||
|
||||
| | DQN | DQN+target network | Double DQN |
|
||||
| :--------------------: | :--------------: | :----------------: | :----------------: |
|
||||
| 最优动作的选取 | 策略网络$\theta$ | 目标网络$\theta^-$ | 目标网络$\theta^-$ |
|
||||
| 最优动作价值函数的计算 | 策略网络$\theta$ | 目标网络$\theta^-$ | 策略网络$\theta$ |
|
||||
|
||||
由此可以看出如何解耦，在传统的DQN+目标网络的方法上，最优动作的选取 与 最优动作价值函数的计算 两步是耦合的，但是Double DQN解耦二者，达到了缓解高估的效果。至于为什么要这么做，就需要清晰的了解高估问题是如何产生的，作者在下一部分明确的证明了高估现象的发生与高估的上下限，并使用实验验证了理论。
|
||||
|
||||
|
||||
|
||||
## 四. 高估问题
|
||||
|
||||
本文另一贡献就是系统的分析了高估问题产生的原因和如何影响了Q-Learning。
|
||||
|
||||
### 1. 理论推导
|
||||
|
||||
#### (1) 为什么会产生高估？
|
||||
|
||||
简单来说，因为神经网络等估计方法存在误差，导致估计出的在某一固定状态$s$下，不同动作的动作价值函数$Q(A_t=a_i, S_t=s)$相对真实值$Q_*(A_t=a_i, S_t=s)$估计误差。假设估计噪声为高斯，无偏均值为0，误差可正可负，到此并无大碍，但是接下来的更新时的操作计算TD-target的时候，如公式$(3)$，使用了max操作，这导致在这一步的误差始终为正的，造成正的偏差，这就是导致高估的原因。
|
||||
|
||||
举个形象生动的例子：每天食堂拿盒饭，每盒的量500g大致相等，但是有的稍多为530g，有的稍少为470g。你每天随机选择一盒作为午餐，一个月下来你的体重没有变化，因为吃到的盒饭期望是每盒的平均值500g。但是第二个月你通过灵敏的视觉，每天都挑最多的那一盒，一个月下来胖了三斤，因为这时候吃到盒饭的期望为最大值530g。
|
||||
|
||||
选择最多的盒饭的过程就是max操作，你吃进去的饭通过公式$(1)$消化（更新），更新了你的体重，也就是动作价值函数的估值。
|
||||
|
||||
#### (2) 高估指标的理论推导
|
||||
|
||||
Thrun and Schwartz (1993)首先发现了高估的现象，表明如果动作值包含均匀分布在区间$[-\epsilon,\epsilon]$中的随机误差，则每个目标被高估到上限 $\gamma \in \frac{m-1}{m+1}$ ，其中 m 是动作的数量。
|
||||
|
||||
由贝尔曼最优方程可以得出最优动作价值函数与最优状态价值函数之间的关系：
|
||||
|
||||
$$Q_*(s,a)=V_*(s) \tag{5} $$
|
||||
|
||||
因为环境固定，奖励固定时，状态价值函数为常量，假设：任意动作价值函数的无偏估计值为$Q_t(s,a)$，则有等式$(6)$成立
|
||||
|
||||
$$ \sum_a (Q_t(s,a)-V_*(s))=0 \tag{6} $$
|
||||
|
||||
即使定义估计是无偏的，平均误差为零，但不是每个估计的误差均为零，也会有以下情况的产生：
|
||||
|
||||
$$\frac{1}{m} \sum_a(Q_t(s,a)-V_*(s))^2=C (m>1为动作个数，C>0为实数) \tag{7} $$
|
||||
|
||||
在这种假设下，使用$(3)$中的max操作，利用$(2)$进行价值函数的更新时，$max_aQ_t(s,a) \geq V_*(s)+ \sqrt{\frac{C}{m-1}}$ ,得到了高估的下限。
|
||||
|
||||
文中特意提到，Double Q-Learning的高估下限为0。
|
||||
|
||||
证明可以参考原文附录，很详细，在此不赘述。
|
||||
|
||||
#### (3) 为什么Double DQN可以解决高估？
|
||||
|
||||
接着盒饭说。此时你感觉自己有点胖，命令你的室友替你拿盒饭，无论你的室友怎样拿，肯定不会比你自己拿的时候（挑最重的拿）多，即$Q(s,a_*;\theta^-) \leq \substack{max\\a}Q(s,a)$，也就减少了目标的高估影响，从而减少了对动作价值函数的估计。
|
||||
|
||||
|
||||
|
||||
### 2. 实验
|
||||
|
||||
本文共做两次实验验证以上理论推导
|
||||
|
||||
#### 实验一：验证Q-Learning与Double Q-Learning在价值函数估计上的性能比较
|
||||
|
||||
|
||||
|
||||
作者实验证明，上图中横坐标为动作数，纵坐标为估计的Q值与最优值的误差（重复100次取平均），橙色为Q-learning，蓝色为Double Q-learning，可以看出随着动作数增加，Q-learning误差逐渐增大，而Double Q-learning基本无偏。
|
||||
|
||||
|
||||
|
||||
#### 实验二：通过参数拟合对比试验验证高估来源，并验证Double Q-Learning能有效缓解高估问题
|
||||
|
||||
|
||||
|
||||
证明了Double Q-learning能够减少过拟合后，作者做了三组实验**模仿参数拟合**，以验证高估产生。
|
||||
|
||||
图表中横坐标为状态，共有13个状态，纵坐标为Q值的大小。共有十个动作。
|
||||
|
||||
- 左列中，紫色的线代表每个状态真实的最优Q值，绿线为动作价值函数的真实值，绿点为真实的不包含噪声的采样点。动作仅仅在13个状态中的11上采样，在未采样点上观察情况。第一行和第二行实验使用6阶多项式去拟合，第三行实验使用9阶多项式。可以看出左图第二行在采样点上的逼近也不精确，是由于多项式阶数低不够灵活；左图第三行可以看出，虽然在采样点上逼近都很好，但在未采样的的地方误差很大，过拟合。
|
||||
- 中列三行图，每幅图中10条绿线是10个动作分别对应的动作值函数，虚线是每个状态下最大动作值。可以看出**最大动作值基本都比左边图中的真实最优Q值大**，当我们使用这些动作价值函数的估计进行Q-Learning的更新时，**使用公式$(2)$ 中$max_aQ_t(s,a) $, 高估现象产生**。
|
||||
- 右列三行图，橙线是中间图中黑色虚线与左边图中紫线作差的结果，即高估，蓝线是使用了Double Q-Learning的估计效果，蓝线的平均值更接近0，这表明**Double Q-Learning确实可以减少Q-Learning在函数逼近中的高估问题**。
|
||||
|
||||
通过实验，发现不够灵活的函数逼近对Q值的估计不精确，但是**足够灵活的函数逼近在未知状态中会产生更大误差**，**导致更高的高估**，DQN就是一种非常灵活的函数逼近，使用了神经网络来逼近价值函数。而高估最终会阻止学习到最优策略，作者后面也通过Atari上的实验证明了这点，且通过Double Q-Learning减少高估最终策略也会得到改善。
|
||||
|
||||
### 3.高估如何影响DQN？
|
||||
|
||||
选择是相对的，均匀的高估不会对动作的选择造成影响。
|
||||
|
||||
真正造成影响的是：高估是非均匀的，回到吃盒饭的例子。你和我有一样的体质（吃-涨的比例相同），我比你稍微重，我们每次都只拿最多的盒饭530g，一个月涨的体重都一样，一个月之后还是我比你稍微重。但是你吃的是A种盒饭，我吃的是B种盒饭，这就会导致非均匀高估，导致你可能长胖更快一点，一个月之后甚至超过我，**导致次最优解**。
|
||||
|
||||
重要的事情说三遍：**均匀高估无影响，真正产生影响的是非均匀高估**，此后将高估一词指代非均匀高估。
|
||||
|
||||
## 五. 基于Atari2006的实验
|
||||
|
||||
### 1. 训练细节
|
||||
|
||||
网络架构是一个卷积神经网络（Fukushima, 1988; LeCun et al., 1998），具有 3 个卷积层和一个全连接隐藏层（总共大约 150 万个参数）。网络将最后四帧作为输入，输出每个动作的动作值。在每场游戏中，网络都在单个 GPU 上训练 200M 帧，或大约 1 周。
|
||||
|
||||
### 2.实验结果
|
||||
|
||||
|
||||
|
||||
作者在6款游戏上重复进行实验，得出以下结果
|
||||
|
||||
- 1， 2行展示了六款游戏的真实价值与估计价值，蓝色为DoubleDQN,红色为DQN。肉眼可见，DoubleDQN的价值拟合更趋近于真实值，相比DQN高估现象减弱明显。并且其中两家款游戏的高估十分严重。
|
||||
- 选择高估现象作为严重的两款游戏（中下），展示其训练期间的得分情况：当高估开始时分数下降，证明了高估现象可以影响算法性能。使用 Double DQN 学习更加稳定。
|
||||
|
||||
最后，为了证明算法的稳定性，采用了不同的时间点开始切入学习（让人先玩一段时间，智能体再接手），发现DDQN的结果更加稳定，并且DDQN的解并没有利用到环境的相关特性。
|
||||
|
||||
##### 注：更多的实验结果篇幅原因这里不再做更多实验展示
|
||||
|
||||
|
||||
|
||||
## 六.本文的贡献
|
||||
|
||||
这篇论文有五个贡献。
|
||||
|
||||
- 首先，展示了为什么 Q-Learning存在高估的问题。
|
||||
- 其次，通过分析 Atari 游戏的价值估计，发现这些高估在实践中比之前认为的更为普遍和严重。
|
||||
- 第三，证明可以使用Double Q-Learning 学习有效地减少高估，从而使学习更加稳定和可靠。
|
||||
- 第四，提出了一种Double DQN具体实现，它使用 DQN 算法的现有架构和深度神经网络，无需额外的网络或参数。
|
||||
- 最后，展示了 Double DQN 找到了更好的策略，在 Atari 2600 域上获得了当时最优的结果。
|
||||
|
||||
## 七.作者介绍
|
||||
|
||||
于天琪，男，20多岁，单身，就读于哈尔滨工程大学陈赓实验班\
|
||||
知乎主页：https://www.zhihu.com/people/Yutianqi \
|
||||
qq:2206422122 \
|
||||
欢迎交流，互相学习
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
176
papers/DQN/Dueling Network Architectures for Deep Reinforceme.md
Normal file
176
papers/DQN/Dueling Network Architectures for Deep Reinforceme.md
Normal file
@@ -0,0 +1,176 @@
|
||||
# Dueling Network Architectures for Deep Reinforcement Learning
|
||||
|
||||
## 〇. 文章信息
|
||||
|
||||
**Dueling Network Architectures for Deep Reinforcement Learning**
|
||||
|
||||
Ziyu Wang、Tom Schaul、Matteo Hessel、Hado van Hasselt、Marc Lanctot、Nando de Freitas
|
||||
|
||||
Google DeepMind
|
||||
|
||||
[https://arxiv.org/abs/1511.06581](https://arxiv.org/abs/1511.06581 "https://arxiv.org/abs/1511.06581")
|
||||
|
||||
## **一、写作动机**
|
||||
|
||||
Dueling DQN出现以前，基于深度学习RL的大多数方法都是用标准的神经网络结构，如MLP、LSTM等。此类工作的重点是改进控制和RL算法，或将现有的神经网络架构推广到RL中。
|
||||
|
||||
本文旨在提出一种适用于Model-free的RL算法的神经网络结构，该结构具有很好地灵活性和互补性。
|
||||
|
||||
## **二、** 预备知识
|
||||
|
||||
 若 $s_t$是智能体感知到的由 $M$个图像帧组成的视频，则有：
|
||||
|
||||
$$
|
||||
s_t = (x_{t−M+1},\cdots,x_t)\in S
|
||||
$$
|
||||
|
||||
与之对应的，$a_t$是智能体备选动作的离散集，则 $a_t \in A={1,2,3,\cdots,|A|}$； 游戏模拟器产生的奖励信号则为 $r_t$。智能体的目标是最大化折扣汇报 $R_t$( $R_t= \sum _{r=t}^\infty \gamma^{r-t}r_t$)，在这个公式中， $\gamma\in[0,1]$是折扣因子，它权衡了即时和未来奖励的重要性。
|
||||
|
||||
对于根据随机策略 $\pi$ 行动的智能体，其状态-动作对$(s, a)$ 和状态 $s$ 的值定义如下：
|
||||
|
||||
$Q^{\pi}(s,a) = E[R_{t}|s_{t}=s,a_{t}=a,\pi]$（动作价值函数）
|
||||
|
||||
$V^{\pi}(s) = E_{a \sim \pi(s)}[Q^{\pi}(s,a)]$（状态价值函数）
|
||||
|
||||
  $Q^{\star}(s, a) = \mathop{max}\limits_{\pi} Q^\pi(s, a)$（最优动作价值函数）
|
||||
|
||||
$V^{\star}(s)=\mathop{max}\limits_{\pi}V^{\pi}(s)$（最优状态价值函数）
|
||||
|
||||
  $A^{\pi}(s,a) = Q^{\pi}(s,a) - V^{\pi}(s,a)$（优势函数）
|
||||
|
||||
**Theorem 1：**$V^{\star}(s) = \mathop{max}\limits_{a} Q^{\star}(s, a)$ （最优价值优势函数等于最优动作价值函数关于动作 $a$的最大值）
|
||||
$$
|
||||
A^{\star}(s, a)=Q^{\star}(s, a)-V^{\star}(s).（同时对左右两边关于动作a求最大值）
|
||||
$$
|
||||
|
||||
$$
|
||||
\mathop{max}\limits_{a}A^{\star}(s, a)=\mathop{max}\limits_{a}Q^{\star}(s, a)-V^{\star}(s)
|
||||
$$
|
||||
|
||||
$$
|
||||
\mathop{max}\limits_{a}A^{\star}(s, a) = \mathop{max}\limits_{a}Q^{\star}(s, a) - \mathop{max}\limits_{a}Q^{\star}(s, a) =0
|
||||
$$
|
||||
|
||||
另外有：
|
||||
|
||||
$$
|
||||
A^{\star}(s, a)=Q^{\star}(s, a)-V^{\star}(s) \Rightarrow Q^{\star}(s, a)=A^{\star}(s, a)+V^{\star}(s)
|
||||
$$
|
||||
|
||||
$$
|
||||
Q^{\star}(s, a)=A^{\star}(s, a)+V^{\star}(s) \Rightarrow Q^{\star}(s, a)=A^{\star}(s, a)+V^{\star}(s)-0
|
||||
$$
|
||||
|
||||
$$
|
||||
A^{\star}(s, a)+V^{\star}(s)+0 = A^{\star}(s, a)+V^{\star}(s)-\mathop{max}\limits_{a}A^{\star}(s, a)
|
||||
$$
|
||||
|
||||
**Theorem 2：** $Q^{\star}(s, a)=A^{\star}(s, a)+V^{\star}(s)-\mathop{max}\limits_{a}A^{\star}(s, a)$
|
||||
|
||||
### 2.1 Deep Q-networks
|
||||
|
||||
$Q(s, a; θ)$是神经网络对 $Q^{\star}(s, a)$的近似，神经网络的输入为状态 $s$，通过神经网络将输入映射到一个输出向量中，输出向量为 $s$状态下对每一个动作$a$的打分。
|
||||
|
||||
迭代$i$处的损失函数:
|
||||
|
||||
$$
|
||||
L_i(\theta_i)=E_{s,a,r,s'}[(y_i^{DQN}-Q(s,a;\theta_i))^2]
|
||||
$$
|
||||
|
||||
其中，$y^{DDQN}{i}=r+\gamma Q(s'+ \mathop{max}\limits_{a'}Q(s',a';\theta^{-}))$。
|
||||
|
||||
另外，还可以从梯度下降和经验回放的角度对训练的方式进行修改。
|
||||
|
||||
* 梯度下降
|
||||
|
||||
$$
|
||||
\nabla_{\theta_i} L_i(\theta_i)=E_{s,a,r,s'}[(y_i^{DQN}-Q(s,a;\theta_i))\nabla_{\theta_i}Q(s,a;\theta_i)]
|
||||
$$
|
||||
|
||||
* 经验回放
|
||||
|
||||
$$
|
||||
L_i(\theta_i) = E_{s,a,r,s'} \sim u(D)[y_i^{DQN}-Q(s,a;\theta_i))^2]
|
||||
$$
|
||||
|
||||
在学习过程中，智能体积累了一个数据集 $D_t = {e_1, e_2, . . . , e_t}$，其中经验$e_t = (s_t, a_t, r_t, s_{t+1})$ 来自许多回合。
|
||||
|
||||
### 2.2 Double Deep Q-networks
|
||||
|
||||
$$
|
||||
y^{DDQN}_{i}=r+\gamma Q(s'+ argmax_{a'}Q(s',a';\theta_{i};\theta^{-}))
|
||||
$$
|
||||
|
||||
DDQN与DQN基本一致，只是改变了 $y^{DDQN}_{i}$的表达式。
|
||||
|
||||
## **三、Dueling Network**的架构
|
||||
|
||||
与DQN不同，Dueling Network近似的是 $A^{\star}(s, a)$和 $V^{\star}(s)$，分别为 $A(s,a;\theta,\alpha)$和 $V(s;\theta,\beta)$。这也就意味着，Dueling Network可以使用同一个卷积网络的参数来提取特征，但输出则使用不同的结构。
|
||||
|
||||
|
||||
|
||||
具体地说，根据**Theorem 2**，有：
|
||||
|
||||
$$
|
||||
Q(s, a; \theta, \alpha, \beta) = V (s; \theta, \beta) + A(s, a; \theta, \alpha)-\mathop{max}\limits_{a}A(s, a; \theta, \alpha)
|
||||
$$
|
||||
|
||||
由于Dueling Network只是改变了网络的架构，所以训练网络的方法与DQN和DDQN一致，所有基于DQN的训练改进都可以用在Dueling Network上面。
|
||||
|
||||
### 3.1 $\mathop{max}\limits_{a}A(s, a; θ, α)$ 的作用
|
||||
|
||||
因为 $Q^{\star}(s, a)=A^{\star}(s, a)+V^{\star}(s)$，所以利用这种方式得到的 $Q^{\star}(s, a)$不唯一。
|
||||
|
||||
若同时给$A^\star$增一个数字，给$V^\star$减少相同的数字，则会得到与之前相同的$Q^{\star}(s, a)$。而增加 $\mathop{max}\limits_{a}A(s, a; θ, α)$一项后就不会出现这种情况。
|
||||
|
||||
### 3.2 实际使用中的 $\mathop{max}\limits_{a}A(s, a; θ, α)$
|
||||
|
||||
在实际的使用中，往往 $Q(s, a; \theta, \alpha, \beta)$中的第三项不使用$\mathop{max}\limits_{a}A(s, a; \theta, \alpha)$，而使用平均值，即：
|
||||
|
||||
$$
|
||||
Q(s, a; \theta, \alpha, \beta) = V (s; \theta, \beta) + ( A(s, a; \theta, \alpha) − \frac{1} {|A|} \sum_ {a'} A(s, a'; \theta, \alpha) )
|
||||
$$
|
||||
|
||||
## **四、** 实验
|
||||
|
||||
### 4.1 策略评估
|
||||
|
||||
为了评估学习到的 $Q$ 值，论文选择了一个简单的环境，其中可以为所有 $(s, a) ∈ S × A$ 分别计算准确的 $Q_\pi(s,a)$值。
|
||||
|
||||
这个环境，称之为走廊，由三个相连的走廊组成。走廊环境示意图如（a）所示，智能体从环境的左下角开始，必须移动到右上角才能获得最大的奖励。共有 5 种动作可用：上、下、左、右和无操作。两个垂直部分都有 10 个状态，而水平部分有 50 个状态。
|
||||
|
||||
论文在走廊环境的三种变体上分别使用 5、10 和 20 个动作将单流 Q 架构与Dueling Network架构进行了比较（10 和 20 动作变体是通过在原始环境中添加无操作而形成的）。
|
||||
|
||||
单流架构是一个三层 MLP，每个隐藏层有 50 个单元。Dueling Network架构也由三层组成。然而，在 50 个单元的第一个隐藏层之后，网络分支成两个流，每个流都是具有 25 个隐藏单元的两层 MLP。
|
||||
|
||||
|
||||
|
||||
结果表明，通过 5 个动作，两种架构以大致相同的速度收敛。然而，当我们增加动作数量时，Dueling Network架构比传统的 Q 网络表现更好。在Dueling Network中，流 $V (s; θ, β)$ 学习到一个通用值，该值在状态 $s$ 处的许多相似动作之间共享，从而导致更快的收敛。
|
||||
|
||||
### 4.2 General Atari Game-Playing
|
||||
|
||||
论文在由 57 个 Atari 游戏组成的 Arcade Learning Environment上对提出的方法进行了综合评估。
|
||||
|
||||
论文的网络架构具有与 DQN 相同的低级卷积结构。有 3 个卷积层，后面是 2 个全连接层。第一个卷积层有 32 个步长为 4 的 8×8 滤波器，第二个是 64 个步长为 2 的 4×4 滤波器，第三个也是最后一个卷积层由 64 个步长为 1 的 3×3 滤波器组成。由于A和V流都将梯度传播到反向传播中的最后一个卷积层，论文将进入最后一个卷积层的组合梯度重新缩放 1/√2。这种简单的启发式方法温和地增加了稳定性。此外，我们对梯度进行裁剪，使其范数小于或等于 10。
|
||||
|
||||
**评估函数：**
|
||||
|
||||
$$
|
||||
30 no-op=\frac{Score_{Agent} − Score_{Baseline}} {max\{Score_{Human}, Score_{Baseline}\} − Score_{Random}}
|
||||
$$
|
||||
|
||||
**结果：**
|
||||
|
||||
|
||||
|
||||
Single Clip 的性能优于 Single。我们验证了这种增益主要是由梯度裁剪带来的。出于这个原因，我们在所有新方法中都加入了梯度裁剪。Duel Clip 在 75.4% 的游戏中（57 场中有 43 场）的表现优于 Single Clip。与单一基线相比，它在 80.7%（57 场比赛中的 46 场）的比赛中也获得了更高的分数。在所有有 18 个动作的游戏中，Duel Clip 有 86.6% 的几率更好（30 个中有 26 个）。这与上一节的研究结果一致。总体而言，Duel智能体 (Duel Clip) 在 57 场比赛中的 42 场比赛中达到了人类水平的表现。
|
||||
|
||||
## 五、贡献
|
||||
|
||||
1. 能够使Q网络更好地收敛。因为针对动作价值Q ，传统的DQN算法直接进行Q值估计，而Dueling DQN则是将其拆分为两项：V和A，即状态价值函数V和优势函数 A，这样的好处就是能够在Q值相近的时候，通过拆解出来的A找到那个最优的动作。
|
||||
|
||||
2. 鲁棒性更好。在给定状态的 Q 值之间的差异通常非常小的情况下，这种尺度差异可能导致更新中的少量噪声可能导致动作的重新排序，从而使策略突然切换。但是因为有具有优势函数A，所以Dueling Network架构对这种效果具有鲁棒性。
|
||||
|
||||
## 六、个人介绍
|
||||
|
||||
程岳，研究生，重庆邮电大学，目前研究方向为模糊时间序列分析、多源异构数据融合，大数据分析与智能决策重庆市重点实验室。
|
||||
64
papers/DQN/Playing Atari with Deep Reinforcement Learning.md
Normal file
64
papers/DQN/Playing Atari with Deep Reinforcement Learning.md
Normal file
@@ -0,0 +1,64 @@
|
||||
## Playing Atari with Deep Reinforcement Learning
|
||||
|
||||
作者： Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, Martin Riedmiller
|
||||
|
||||
单位：Deepmind
|
||||
|
||||
论文链接：https://arxiv.org/abs/1312.5602
|
||||
|
||||
**亮点：作者提出了用深度学习模型来拟合价值函数，结合Q-Learning进行训练的深度强化学习算法DQN，并且在Atari 2600上进行了验证。**
|
||||
|
||||
### **Motivation (Why):**
|
||||
|
||||
传统RL依赖手工特征和线性的价值函数，性能受限。DL的技术进步，可以在原始数据中提取高维信息，不需要再手工提取特征。如果把DL和RL结合起来，RL算法性能可以显著提升，但是这有以下两个问题要克服：
|
||||
|
||||
1. DL算法需要大量有标签的数据，而RL算法的训练只能返回一个标量的奖励，并且是稀疏、充满噪声和延迟的。
|
||||
2. DL需要数据是独立同分布的，而RL算法的数据既不是独立的，分布也不是固定的。RL算法中的状态之间往往是高度相关的，而且RL的数据分布也会随着算法开始学习新的行为而改变。
|
||||
|
||||
### **Main Idea (What):**
|
||||
|
||||
作者通过使用一个CNN网络和Q-Learning算法结合的DQN算法来解决上述问题。具体来说，动机中的DL算法需要大量有标签数据的问题是由Q-Learning训练中的Fixed Q-target思路解决的，而RL算法中数据不是独立同分布的问题是通过经验回放来缓解（alleviate）的。
|
||||
|
||||
### **Main Contribution (How):**
|
||||
|
||||
与之前TD-Gammon直接在On-policy的策略中学习不同，DQN采取了Off-policy的形式，将采样数据存在一个固定大小的名为经验回放池的集合中，训练中将集合划分成多个Mini-batch，采用SGD优化器更新权重。对于在Q-learning中使用经验回放策略来缓解非独立同分布的问题，本文提出的算法如下图所示：
|
||||
|
||||
|
||||
|
||||
以上是DQN完整的算法，算法根据 $\epsilon$ -贪婪策略在状态 $s_t$ 选择并执行一个行动 $a_t$， 观测系统给出的奖励 $r_t$ 以及采取动作后的游戏画面 $x_{t+1}$, 由于使用任意长度的历史作为神经网络的输入是很困难的，因此作者通过序列转换函数 $\phi()$，将序列 $s_{t+1} = s_t,a_t,x_t+1$ 转化成 状态向量 $s_{t+1}$, 使Q函数可以在固定长度的历史上工作。此外，作者利用一种被称为经验重放的技术， 将算法在不同回合中各时间步长采集的经验数据 $e_t = (s_t, a_t, r_t, s_{t+1})$ 汇总存放在一个经验重放存储器 $D=e_1，...，e_N$ 中。在算法内循环中需要对模型进行更新的时候，我们从存储样本的经验重放存储器中随机抽取样本，对模型参数进行更新。
|
||||
|
||||
**本文提出方法的优点：**
|
||||
|
||||
1. Q函数的输入是状态，不是状态-动作对，可以有效减少模型计算量。前者只需要一次计算，将不同动作作为输出层的神经元，选取值最大的那个动作，后者则需要对每个动作都进行一次计算。
|
||||
2. 权重更新是SGD的形式，不是OGD的。可以提高样本利用率，并且对不同状态下不同行为对应Q函数的分布进行平均和平滑处理，避免算法不收敛。
|
||||
|
||||
**待改进的地方：**
|
||||
|
||||
经验回放部分只储存最近的经验，并且取样的时候是随机取样的，并不区分比较重要的样本，还因为内存问题不停地覆盖先前的经验。可以用更复杂的取样策略，来区分出哪些样本更重要并加以利用。
|
||||
|
||||
**结果：**
|
||||
|
||||
|
||||
|
||||
DQN在7个Atari 2600游戏上的得分有6个超过了最好方法，有3个游戏超过了人类专家，但在Q*bert、Seaquest、Space Invaders等游戏上与人类相差甚远，作者评价它们更具挑战性，需要要求网络找到可以延伸到更长时间尺度的策略。
|
||||
|
||||
|
||||
|
||||
**个人思考**
|
||||
|
||||
1. 作者在这7个游戏上用的是同一种网络和算法以及同样的超参数。
|
||||
2. 可能是为了突出这是第一篇DL和RL的文章，作者在文中不停地强调DQN用的就是游戏的原始图像，没有做任何人工提取特征的工作，并且除迫不得已的原因外（游戏设置问题）在训练和测试都没有对超参数进行改动。
|
||||
3. 作者前文中也提到了非线性价值函数往往缺少收敛性的保证，这也导致了之前的大量研究都是用收敛性的更好的线性价值函数。但在DQN的实验中仍没有做收敛性的理论分析，只是说在大量的实验中我们没有遇到这个问题。
|
||||
|
||||
|
||||
|
||||
### 个人简介
|
||||
|
||||
吴文昊，西安交通大学硕士在读
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
534
papers/DQN/Prioritized Experience Replay.md
Normal file
534
papers/DQN/Prioritized Experience Replay.md
Normal file
@@ -0,0 +1,534 @@
|
||||
# JoyRL论文阅读《Prioritized Experience Replay》 + Python代码
|
||||
作者：Tom Schaul, John Quan, Ioannis Antonoglou and David Silver
|
||||
|
||||
实验室：Google DeepMind
|
||||
|
||||
邮箱：{schaul,johnquan,ioannisa,davidsilver}@google.com
|
||||
|
||||
论文地址：[https://arxiv.org/abs/1511.05952](https://arxiv.org/abs/1511.05952) Published as a conference paper at ICLR 2016
|
||||
|
||||
- **<u>*标题有问题*</u>**
|
||||
|
||||
|
||||
## 一、提出背景
|
||||
**深度强化学习算法**，结合了深度学习强大的环境感知能力和强化学习的决策能力，近年来被广泛应用于游戏、无人自主导航、多智能体协作以及推荐系统等各类人工智能新兴领域。强化学习作为机器学习的一个重要分支，其本质是智能体以“**试错**”的方式在与环境中学习策略，与常见的监督学习和非监督学习不同，强化学习强调智能体与环境之间的交互，在交互过程中通过不断学习来改变策略得到最大回报，以得到最优策略。
|
||||
|
||||
强化学习由于其算法特性，并没有现成的数据集，而仅靠单步获得的数据对未知的复杂环境信息进行感知决策并不高效可靠。DQN算法结合神经网络的同时，结合了**经验回放机制**，针对Q-learning的局限性，打消了采样数据相关性，使得数据分布变得更稳定。
|
||||
|
||||
但随着DQN算法的应用，研究人员发现，基于经验回放机制的DQN算法，仅采用**均匀采样**和**批次更新**，导致部分数量少但价值高的经验没有被高效的利用。针对上述情况，Deep Mind团队提出了**Prioritized Experience Replay（优先经验回放）机制**，本文将对该论文展开详细介绍。
|
||||
|
||||
## 二、摘要和结论
|
||||
### 1 摘要
|
||||
经验重放（Experience replay）使在线强化学习（Online reinforcement learning）智能体可以记住和重用过去的经验。先前的经验重放是从存储器中统一采样，只是以与最初经验的相同频率进行重采样，而不管其重要性如何。该论文开发了一个优先考虑经验的框架，以便更频繁地重播重要的数据，从而更有效地学习。文章中将优先经验回放机制与DQN网络结合，在49场比赛中有41场具有统一重播的DQN表现优于DQN。
|
||||
|
||||
### 2 结论
|
||||
文章为经验回放机制及其几个变体，设计了可以扩展到大型重放内存的实现，发现优先级重放可以将学习速度提高2倍，并在Atari Baseline上带来了最新的性能。
|
||||
|
||||
## 三、基本理论
|
||||
### 1 经验回放（Experience Replay）：
|
||||
- 创建一个经验池（Experience Replay Buffer），每一次Agent选择一个动作与环境交互就会储存一组数据$e_t = (s_t, a_t, r_t, s_{t+1})$到经验池中。
|
||||
|
||||
- 维护这个经验池（队列），当储存的数据组数到达一定的阈值，数据到就会从队列中被提取出来。
|
||||
|
||||
- 采用均匀采样的方式进行数据提取。
|
||||
|
||||
上述方法解决了经验数据的相关性（Correlated data）和非平稳分布（Non-stationary distribution）问题。它的做法是从以往的状态转移（经验）中**均匀采样**进行训练。优点是数据利用率高，一个样本被多次使用，且连续样本的相关性会使参数更新的方差（Variance）比较大，以此减少这种相关性。
|
||||
|
||||
然而，采用均匀采样方式存在的问题，作者举了例子如图所示：
|
||||
左图表示一个（稀疏奖励）环境有初始状态为1，有n个状态，两个可选动作，仅当选择绿色线条动作的时候可以得到 reward=1 的奖励；右图为实验结果，黑色曲线代表均匀采样的结果，蓝色曲线为研究人员提出的一个名为“oracle”的最优次序，即每次采样的transition均采用“最好”的结果，实验结果可看出每次采用最优次序的方法在稀疏奖励（Reward sparse）环境能够明显优于均匀采样。
|
||||
|
||||
那么如何在实际应用当中找到这个“最优”次序，即如何在采样前提前设计好一个次序，使得每次采样的数据都尽可能让agent高效学习呢？
|
||||
### 2 优先经验回放（Prioritized Experience Replay，PER）
|
||||
针对经验回放机制存在的问题，DeepMind团队提出了两方面的思考：要存储哪些经验（**which experiences to store**），以及要重放哪些经验（**which experiences to replay，and how to do so**）。论文中仅针对后者，即怎么样选取要采样的数据以及实验的方法做了详尽的说明和研究。
|
||||
|
||||
PER机制将TD-error（时序误差）作为衡量标准评估被采样数据的优先级。TD-error指在时序差分中**当前Q值**和它**目标Q值**的差值,误差越大即表示该数据对网络参数的更新越有帮助。贪婪（选取最大值）的采样TD-error大的数据训练，理论上会加速收敛，但随之而来也会面临以下问题：
|
||||
|
||||
- TD-error可看做对参数更新的信息增益，信息增益较大仅表示对于当前的价值网络参数而言增益较大，但却不能代表对于后续的价值网络没有较大的增益。若只贪婪的考虑信息增益来采样，当前TD-error较小的数据优先级会越来越低，后面会越来越难采样到该组数据。
|
||||
|
||||
- 贪婪的选择使得神经网络总是更新某一部分样本，即“经验的一个子集”，很可能导致陷入局部最优，亦或是过估计的发生。
|
||||
|
||||
针对上述PER存在的问题，作者在文中提出了一种随机抽样的方法，该方法介于纯贪婪和均匀随机之间，确保transition基于优先级的被采样概率是单调的，同时即使对于最低优先级的transition也保证非零的概率，随机抽样的方法将在***<u>1.3展开</u>***介绍。
|
||||
|
||||
## 四、相关改进工作
|
||||
### 1 随机优先级（Stochastic Prioritization）
|
||||
论文将采样transition $i$的概率定义为：
|
||||
$$P(i)=\frac{p_i^\alpha}{\sum_k p_k^\alpha}$$
|
||||
其中$p_i>0$表示transition $i$的优先级。指数$α$表示决定使用多少优先级，可看做一个trade-off因子，用来权衡uniform和greedy的程度，当$α=0$时表示均匀采样，$α=1$是表示贪婪（选取最大值）采样。
|
||||
|
||||
在DQN中：$\delta=y -Q(s, a)$, $\delta$表示TD-error，即每一步当前Q值与目标值$y$之间的差值，在更新过程中也是为了让$\delta^2$的期望尽可能的小。
|
||||
|
||||
文中将随机优先经验回放划分为以下两个类型：
|
||||
|
||||
a）直接的，基于比例的：**Proportional Prioritization**
|
||||
|
||||
b）间接的，基于排名的：**Rank-based Prioritization**
|
||||
|
||||
- **a）Proportional Prioritization**中，根据 $|\delta|$决定采样概率：
|
||||
|
||||
$$p_i=\left|\delta_i\right|+\epsilon$$
|
||||
其中 $\delta$表示TD-eroor，$\epsilon$是一个大于0的常数，为了保证无论TD-error取值如何，采样概率$p_i$仍大于0，即仍有概率会被采样到。
|
||||
- **b）Rank-based Prioritization**中，根据 $|\delta|$ 的 **排名（Rank）** 来决定采样概率：
|
||||
|
||||
$$p_i=\frac{1}{\operatorname{rank}(i)}$$
|
||||
|
||||
作者在文中对两种方法进行了比较：
|
||||
|
||||
**a）从理论层次分析：**
|
||||
**proportional prioritization**优势在于可以直接获得 $|\delta|$ 的信息，也就是它的信息增益多一些；而**rank-based prioritization**则没有 $|\delta|$ 的信息，但其对异常点不敏感，因为异常点的TD-error过大或过小对rank值没有太大影响，也正因为此，**rank-based prioritization**具有更好的鲁棒性。
|
||||
|
||||
**b）从实验层次分析：**
|
||||
结果如下图所示，可以看出这两种方法的表现大致相同。
|
||||
### 2 SumTree
|
||||
Proportional Prioritization的实现较为复杂，可借助SumTree数据结构完成。SumTree是一种树形结构，每片树叶存储每个样本的优先级P，每个树枝节点只有两个分叉，节点的值是两个分叉的和，所以SumTree的顶端就是所有p的和。结构如下图([引自jaromiru.com](https://jaromiru.com/2016/11/07/lets-make-a-dqn-double-learning-and-prioritized-experience-replay/))所示, 顶层的节点是全部p的和。
|
||||
抽样时, 我们会将 p 的总和除以 batch size, 分成 batch size 多个区间，即$n={ sum(p) }/{batchsize}$.。如果将所有节点的优先级加起来是42, 我们如果抽6个样本, 这时的区间拥有的 priority 可能是这样:[0-7], [7-14], [14-21], [21-28], [28-35], [35-42]
|
||||
|
||||
然后在每个区间里随机选取一个数. 比如在第区间 [21-28] 里选到了24, 就按照这个 24 从最顶上的42开始向下搜索. 首先看到最顶上 42 下面有两个 child nodes, 拿着手中的24对比左边的 child 29, 如果左边的 child 比自己手中的值大, 那我们就走左边这条路, 接着再对比 29 下面的左边那个点 13, 这时, 手中的 24 比 13 大, 那我们就走右边的路, 并且将手中的值根据 13 修改一下, 变成 24-13 = 11. 接着拿着 11 和 13 左下角的 12 比, 结果 12 比 11 大, 那我们就选 12 当做这次选到的 priority, 并且也选择 12 对应的数据。
|
||||
|
||||
以上面的树结构为例，根节点是42，如果要采样一个样本，我们可以在[0,42]之间做均匀采样，采样到哪个区间，就是哪个样本。比如我们采样到了26， 在（25-29）这个区间，那么就是第四个叶子节点被采样到。而注意到第三个叶子节点优先级最高，是12，它的区间13-25也是最长的，所以它会比其他节点更容易被采样到。
|
||||
|
||||
如果要采样两个样本，我们可以在[0,21],[21,42]两个区间做均匀采样，方法和上面采样一个样本类似。
|
||||
### 3 消除偏差（Annealing the Bias）
|
||||
使用优先经验回放还存在一个问题是改变了状态的分布，DQN中引入经验池是为了解决数据相关性，使数据（尽量）独立同分布。但是使用优先经验回放又改变了状态的分布，这样势必会引入偏差bias，对此，文中使用重要性采样结合退火因子来消除引入的偏差。
|
||||
|
||||
在DQN中，梯度的计算如下所示：
|
||||
$$
|
||||
\nabla_{\theta_i} L\left(\theta_i\right)=\mathbb{E}_{s, a, r, s^{\prime}}\left[\left(r+\gamma \max _{a^{\prime}} Q\left(s^{\prime}, a^{\prime} ; \theta_i\right)-Q\left(s, a ; \theta_i\right)\right) \nabla_{\theta_i} Q\left(s, a ; \theta_i\right)\right]（1）
|
||||
$$
|
||||
在随机梯度下降（SGD）中可表示为：
|
||||
$$
|
||||
\nabla_\theta L(\theta)=\delta \nabla_\theta Q(s, a)
|
||||
$$
|
||||
而重要性采样，就是给这个梯度加上一个权重$w$
|
||||
$$
|
||||
\nabla_\theta L(\theta)=w \delta \nabla_\theta Q(s, a)
|
||||
$$
|
||||
重要性采样权重$w_i$在文中定义为：
|
||||
$$
|
||||
w_i=\left(\frac{1}{N} \cdot \frac{1}{P(i)}\right)^\beta
|
||||
$$
|
||||
$N$ 表示Buffer里的样本数，而 $\beta$ 是一个超参数，用来决定多大程度想抵消 Prioritized Experience Replay对收敛结果的影响。如果 $\beta=0$，表示完全不使用重要性采样 ；$\beta=1$时表示完全抵消掉影响，由于 $(s, a)$ 不再是均匀分布随机选出来的了，而是以 $P(i)$ 的概率选出来，因此，如果 $\beta=1$ ， 那么 $w$ 和 $P(i)$ 就正好抵消了，于是Prioritized Experience Replay的作用也就被抵消了，即$\beta=1$等同于DQN中的 Experience Replay。
|
||||
|
||||
为了稳定性，我们需要对权重 $w$ 归一化，但是不用真正意义上的归一化，只要除上 $\max _i w_i$ 即可，即：
|
||||
|
||||
$$
|
||||
w_j=(N * P(j))^{-\beta} / \max _i\left(w_i\right)
|
||||
$$
|
||||
|
||||
归一化后的 $w_i$ 在编写代码时可推导转化为：
|
||||
|
||||
$$
|
||||
w_j=\frac{(N * P(j))^{-\beta}}{\max _i\left(w_i\right)}=\frac{(N * P(j))^{-\beta}}{\max _i\left((N * P(i))^{-\beta}\right)}=\frac{(P(j))^{-\beta}}{\max _i\left((P(i))^{-\beta}\right)}=\left(\frac{P_j}{\min _i P(i)}\right)^{-\beta}
|
||||
$$
|
||||
|
||||
## 五、PER代码
|
||||
### 1 Prioritized Replay DQN 算法流程
|
||||
**算法输入**：迭代轮数 $T$ ，状态特征维度 $n$ ，动作集 $A$ ，步长 $\alpha$ ，采样权重系数 $\beta$ ，衰减因子 $\gamma$ ，探索率 $\epsilon$ ，当前 $Q$ 网络 $Q$ ，目标 $\mathrm{Q}$ 网络 $Q^{\prime}$ ，批量梯度下降的样本数 $m$ ，目标 $\mathrm{Q}$ 网络参数更新频率 $C$ ，SumTree的叶子节点数 $S$ 。
|
||||
|
||||
**输出**: Q网络参数。
|
||||
|
||||
1. 随机初始化所有的状态和动作对应的价值 $Q$. 随机初始化当前 $\mathrm{Q}$ 网络的所有参数 $w$, 初始化目标Q网络 $Q^{\prime}$ 的参数 $w^{\prime}=w$ 。初始化经验回放SumTree 的默认数据结构，所有SumTree的 $S$ 个叶子节点的优先级 $p_j$ 为 1 。
|
||||
|
||||
2. for i from 1 to $T$ ，进行迭代。
|
||||
|
||||
a) 初始化S为当前状态序列的第一个状态，得到其特征向量 $\phi(S)$
|
||||
|
||||
b) 在 $\mathrm{Q}$ 网络中使用 $\phi(S)$ 作为输入，得到 $\mathrm{Q}$ 网络的所有动作对应的 $\mathrm{Q}$ 值输出。用 $\epsilon$ 一贪婪法在当前 $\mathrm{Q}$ 值输出中选择对应的动作 $A$
|
||||
|
||||
c) 在状态 $S$ 执行当前动作 $A$, 得到新状态 $S^{\prime}$ 对应的特征向量 $\phi\left(S^{\prime}\right)$ 和奖励 $R$, 是否终止状态is_end
|
||||
|
||||
d) 将 $\left\{\phi(S), A, R, \phi\left(S^{\prime}\right), i s_{-} e n d\right\}$ 这个五元组存入SumTree
|
||||
|
||||
e) $S=S^{\prime}$
|
||||
|
||||
f) 从SumTree中采样 $m$ 个样本 $\left\{\phi\left(S_j\right), A_j, R_j, \phi\left(S_j^{\prime}\right), i s_{-} e n d_j\right\}, j=1,2 .,,, m$，每个样本被采样的概率基于 $P(j)=\frac{p_j}{\sum_i\left(p_i\right)}$ ，损失函数权重 $w_j=(N * P(j))^{-\beta} / \max _i\left(w_i\right)$ ，计算当前目标Q值 $y_j$ :
|
||||
|
||||
$$
|
||||
y_j= \begin{cases}R_j & \text { is end }_j \text { is true } \\ R_j+\gamma Q^{\prime}\left(\phi\left(S_j^{\prime}\right), \arg \max _{a^{\prime}} Q\left(\phi\left(S_j^{\prime}\right), a, w\right), w^{\prime}\right) & \text { is end }_j \text { is false }\end{cases}
|
||||
$$
|
||||
|
||||
g)使用均方差损失函数 $\frac{1}{m} \sum_{j=1}^m w_j\left(y_j-Q\left(\phi\left(S_j\right), A_j, w\right)\right)^2$ ，通过神经网络的梯度反向传播来更新Q网络的所有参数 $w$
|
||||
|
||||
h) 重新计算所有样本的TD误差 $\delta_j=y_j-Q\left(\phi\left(S_j\right), A_j, w\right)$，更新SumTree中所有节点的优先级 $p_j=\left|\delta_j\right|$
|
||||
|
||||
i) 如果 $\mathrm{i} \% \mathrm{C}=1$, 则更新目标 $\mathrm{Q}$ 网络参数 $w^{\prime}=w$
|
||||
|
||||
j) 如果 $S^{\prime}$ 是终止状态，当前轮迭代完毕，否则转到步骤b)
|
||||
|
||||
|
||||
### 2 相关代码
|
||||
该部分代码可直接在程序里调用，其中ReplayBuffer（）这个类是传统的的经验回放；PrioritizedReplayBuffer(ReplayBuffer)这个类是优先经验回放。
|
||||
|
||||
```python
|
||||
import numpy as np
|
||||
import random
|
||||
|
||||
from segment_tree import SumSegmentTree, MinSegmentTree
|
||||
|
||||
|
||||
class ReplayBuffer(object):
|
||||
def __init__(self, size):
|
||||
"""Create Replay buffer.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
size: int
|
||||
Max number of transitions to store in the buffer. When the buffer
|
||||
overflows the old memories are dropped.
|
||||
"""
|
||||
self._storage = []
|
||||
self._maxsize = size
|
||||
self._next_idx = 0
|
||||
|
||||
def __len__(self):
|
||||
return len(self._storage)
|
||||
|
||||
def add(self, obs_t, action, reward, obs_tp1, done):
|
||||
data = (obs_t, action, reward, obs_tp1, done)
|
||||
|
||||
if self._next_idx >= len(self._storage):
|
||||
self._storage.append(data)
|
||||
else:
|
||||
self._storage[self._next_idx] = data
|
||||
self._next_idx = (self._next_idx + 1) % self._maxsize
|
||||
|
||||
def _encode_sample(self, idxes):
|
||||
obses_t, actions, rewards, obses_tp1, dones = [], [], [], [], []
|
||||
for i in idxes:
|
||||
data = self._storage[i]
|
||||
obs_t, action, reward, obs_tp1, done = data
|
||||
obses_t.append(np.array(obs_t, copy=False))
|
||||
actions.append(np.array(action, copy=False))
|
||||
rewards.append(reward)
|
||||
obses_tp1.append(np.array(obs_tp1, copy=False))
|
||||
dones.append(done)
|
||||
return np.array(obses_t), np.array(actions), np.array(rewards), np.array(obses_tp1), np.array(dones)
|
||||
|
||||
def sample(self, batch_size):
|
||||
"""Sample a batch of experiences.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
batch_size: int
|
||||
How many transitions to sample.
|
||||
|
||||
Returns
|
||||
-------
|
||||
obs_batch: np.array
|
||||
batch of observations
|
||||
act_batch: np.array
|
||||
batch of actions executed given obs_batch
|
||||
rew_batch: np.array
|
||||
rewards received as results of executing act_batch
|
||||
next_obs_batch: np.array
|
||||
next set of observations seen after executing act_batch
|
||||
done_mask: np.array
|
||||
done_mask[i] = 1 if executing act_batch[i] resulted in
|
||||
the end of an episode and 0 otherwise.
|
||||
"""
|
||||
idxes = [random.randint(0, len(self._storage) - 1) for _ in range(batch_size)]
|
||||
return self._encode_sample(idxes)
|
||||
|
||||
|
||||
class PrioritizedReplayBuffer(ReplayBuffer):
|
||||
def __init__(self, size, alpha):
|
||||
"""Create Prioritized Replay buffer.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
size: int
|
||||
Max number of transitions to store in the buffer. When the buffer
|
||||
overflows the old memories are dropped.
|
||||
alpha: float
|
||||
how much prioritization is used
|
||||
(0 - no prioritization, 1 - full prioritization)
|
||||
|
||||
See Also
|
||||
--------
|
||||
ReplayBuffer.__init__
|
||||
"""
|
||||
super(PrioritizedReplayBuffer, self).__init__(size)
|
||||
assert alpha >= 0
|
||||
self._alpha = alpha
|
||||
|
||||
it_capacity = 1
|
||||
while it_capacity < size:
|
||||
it_capacity *= 2
|
||||
|
||||
self._it_sum = SumSegmentTree(it_capacity)
|
||||
self._it_min = MinSegmentTree(it_capacity)
|
||||
self._max_priority = 1.0
|
||||
|
||||
def add(self, *args, **kwargs):
|
||||
"""See ReplayBuffer.store_effect"""
|
||||
idx = self._next_idx
|
||||
super().add(*args, **kwargs)
|
||||
self._it_sum[idx] = self._max_priority ** self._alpha
|
||||
self._it_min[idx] = self._max_priority ** self._alpha
|
||||
|
||||
def _sample_proportional(self, batch_size):
|
||||
res = []
|
||||
p_total = self._it_sum.sum(0, len(self._storage) - 1)
|
||||
every_range_len = p_total / batch_size
|
||||
for i in range(batch_size):
|
||||
mass = random.random() * every_range_len + i * every_range_len
|
||||
idx = self._it_sum.find_prefixsum_idx(mass)
|
||||
res.append(idx)
|
||||
return res
|
||||
|
||||
def sample(self, batch_size, beta):
|
||||
"""Sample a batch of experiences.
|
||||
|
||||
compared to ReplayBuffer.sample
|
||||
it also returns importance weights and idxes
|
||||
of sampled experiences.
|
||||
|
||||
|
||||
Parameters
|
||||
----------
|
||||
batch_size: int
|
||||
How many transitions to sample.
|
||||
beta: float
|
||||
To what degree to use importance weights
|
||||
(0 - no corrections, 1 - full correction)
|
||||
|
||||
Returns
|
||||
-------
|
||||
obs_batch: np.array
|
||||
batch of observations
|
||||
act_batch: np.array
|
||||
batch of actions executed given obs_batch
|
||||
rew_batch: np.array
|
||||
rewards received as results of executing act_batch
|
||||
next_obs_batch: np.array
|
||||
next set of observations seen after executing act_batch
|
||||
done_mask: np.array
|
||||
done_mask[i] = 1 if executing act_batch[i] resulted in
|
||||
the end of an episode and 0 otherwise.
|
||||
weights: np.array
|
||||
Array of shape (batch_size,) and dtype np.float32
|
||||
denoting importance weight of each sampled transition
|
||||
idxes: np.array
|
||||
Array of shape (batch_size,) and dtype np.int32
|
||||
idexes in buffer of sampled experiences
|
||||
"""
|
||||
assert beta > 0
|
||||
|
||||
idxes = self._sample_proportional(batch_size)
|
||||
|
||||
weights = []
|
||||
p_min = self._it_min.min() / self._it_sum.sum()
|
||||
max_weight = (p_min * len(self._storage)) ** (-beta)
|
||||
|
||||
for idx in idxes:
|
||||
p_sample = self._it_sum[idx] / self._it_sum.sum()
|
||||
weight = (p_sample * len(self._storage)) ** (-beta)
|
||||
weights.append(weight / max_weight)
|
||||
weights = np.array(weights)
|
||||
encoded_sample = self._encode_sample(idxes)
|
||||
return tuple(list(encoded_sample) + [weights, idxes])
|
||||
|
||||
def update_priorities(self, idxes, priorities):
|
||||
"""Update priorities of sampled transitions.
|
||||
|
||||
sets priority of transition at index idxes[i] in buffer
|
||||
to priorities[i].
|
||||
|
||||
Parameters
|
||||
----------
|
||||
idxes: [int]
|
||||
List of idxes of sampled transitions
|
||||
priorities: [float]
|
||||
List of updated priorities corresponding to
|
||||
transitions at the sampled idxes denoted by
|
||||
variable `idxes`.
|
||||
"""
|
||||
assert len(idxes) == len(priorities)
|
||||
for idx, priority in zip(idxes, priorities):
|
||||
assert priority > 0
|
||||
assert 0 <= idx < len(self._storage)
|
||||
self._it_sum[idx] = priority ** self._alpha
|
||||
self._it_min[idx] = priority ** self._alpha
|
||||
|
||||
self._max_priority = max(self._max_priority, priority)
|
||||
|
||||
```
|
||||
以上代码调用的数据结构SumTree，代码如下：
|
||||
|
||||
```python
|
||||
import operator
|
||||
|
||||
|
||||
class SegmentTree(object):
|
||||
def __init__(self, capacity, operation, neutral_element):
|
||||
"""Build a Segment Tree data structure.
|
||||
|
||||
https://en.wikipedia.org/wiki/Segment_tree
|
||||
|
||||
Can be used as regular array, but with two
|
||||
important differences:
|
||||
|
||||
a) setting item's value is slightly slower.
|
||||
It is O(lg capacity) instead of O(1).
|
||||
b) user has access to an efficient ( O(log segment size) )
|
||||
`reduce` operation which reduces `operation` over
|
||||
a contiguous subsequence of items in the array.
|
||||
|
||||
Paramters
|
||||
---------
|
||||
capacity: int
|
||||
Total size of the array - must be a power of two.
|
||||
operation: lambda obj, obj -> obj
|
||||
and operation for combining elements (eg. sum, max)
|
||||
must form a mathematical group together with the set of
|
||||
possible values for array elements (i.e. be associative)
|
||||
neutral_element: obj
|
||||
neutral element for the operation above. eg. float('-inf')
|
||||
for max and 0 for sum.
|
||||
"""
|
||||
assert capacity > 0 and capacity & (capacity - 1) == 0, "capacity must be positive and a power of 2."
|
||||
self._capacity = capacity
|
||||
self._value = [neutral_element for _ in range(2 * capacity)]
|
||||
self._operation = operation
|
||||
|
||||
def _reduce_helper(self, start, end, node, node_start, node_end):
|
||||
if start == node_start and end == node_end:
|
||||
return self._value[node]
|
||||
mid = (node_start + node_end) // 2
|
||||
if end <= mid:
|
||||
return self._reduce_helper(start, end, 2 * node, node_start, mid)
|
||||
else:
|
||||
if mid + 1 <= start:
|
||||
return self._reduce_helper(start, end, 2 * node + 1, mid + 1, node_end)
|
||||
else:
|
||||
return self._operation(
|
||||
self._reduce_helper(start, mid, 2 * node, node_start, mid),
|
||||
self._reduce_helper(mid + 1, end, 2 * node + 1, mid + 1, node_end)
|
||||
)
|
||||
|
||||
def reduce(self, start=0, end=None):
|
||||
"""Returns result of applying `self.operation`
|
||||
to a contiguous subsequence of the array.
|
||||
|
||||
self.operation(arr[start], operation(arr[start+1], operation(... arr[end])))
|
||||
|
||||
Parameters
|
||||
----------
|
||||
start: int
|
||||
beginning of the subsequence
|
||||
end: int
|
||||
end of the subsequences
|
||||
|
||||
Returns
|
||||
-------
|
||||
reduced: obj
|
||||
result of reducing self.operation over the specified range of array elements.
|
||||
"""
|
||||
if end is None:
|
||||
end = self._capacity
|
||||
if end < 0:
|
||||
end += self._capacity
|
||||
end -= 1
|
||||
return self._reduce_helper(start, end, 1, 0, self._capacity - 1)
|
||||
|
||||
def __setitem__(self, idx, val):
|
||||
# index of the leaf
|
||||
idx += self._capacity
|
||||
self._value[idx] = val
|
||||
idx //= 2
|
||||
while idx >= 1:
|
||||
self._value[idx] = self._operation(
|
||||
self._value[2 * idx],
|
||||
self._value[2 * idx + 1]
|
||||
)
|
||||
idx //= 2
|
||||
|
||||
def __getitem__(self, idx):
|
||||
assert 0 <= idx < self._capacity
|
||||
return self._value[self._capacity + idx]
|
||||
|
||||
|
||||
class SumSegmentTree(SegmentTree):
|
||||
def __init__(self, capacity):
|
||||
super(SumSegmentTree, self).__init__(
|
||||
capacity=capacity,
|
||||
operation=operator.add,
|
||||
neutral_element=0.0
|
||||
)
|
||||
|
||||
def sum(self, start=0, end=None):
|
||||
"""Returns arr[start] + ... + arr[end]"""
|
||||
return super(SumSegmentTree, self).reduce(start, end)
|
||||
|
||||
def find_prefixsum_idx(self, prefixsum):
|
||||
"""Find the highest index `i` in the array such that
|
||||
sum(arr[0] + arr[1] + ... + arr[i - i]) <= prefixsum
|
||||
|
||||
if array values are probabilities, this function
|
||||
allows to sample indexes according to the discrete
|
||||
probability efficiently.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
perfixsum: float
|
||||
upperbound on the sum of array prefix
|
||||
|
||||
Returns
|
||||
-------
|
||||
idx: int
|
||||
highest index satisfying the prefixsum constraint
|
||||
"""
|
||||
assert 0 <= prefixsum <= self.sum() + 1e-5
|
||||
idx = 1
|
||||
while idx < self._capacity: # while non-leaf
|
||||
if self._value[2 * idx] > prefixsum:
|
||||
idx = 2 * idx
|
||||
else:
|
||||
prefixsum -= self._value[2 * idx]
|
||||
idx = 2 * idx + 1
|
||||
return idx - self._capacity
|
||||
|
||||
|
||||
class MinSegmentTree(SegmentTree):
|
||||
def __init__(self, capacity):
|
||||
super(MinSegmentTree, self).__init__(
|
||||
capacity=capacity,
|
||||
operation=min,
|
||||
neutral_element=float('inf')
|
||||
)
|
||||
|
||||
def min(self, start=0, end=None):
|
||||
"""Returns min(arr[start], ..., arr[end])"""
|
||||
|
||||
return super(MinSegmentTree, self).reduce(start, end)
|
||||
|
||||
```
|
||||
## 六、总结与展望
|
||||
虽然PER在采用**相同的交互次数**时会获得更高的性能，更加适合**稀疏奖励**或者**高奖励难以获得**的复杂环境，但其花费同样的时间，性能不一定更高，即花的时间要多三四倍。（参考文献6）针对PER耗时问题提出自己的实验和结论，其将总采样消耗的时间划分为三个部分（**采样时间、PER更新时间、算法更新时间**）进行实验，发现添加了原始PER的网络耗时反而更高。
|
||||
|
||||
> The first one is the sample, which needs to search on the sum-tree. When the capacity of EM goes larger, the sampling time, whose time complexity is O(logN), becomes a bottleneck.
|
||||
The second one is PER update, which is the same time complexity as sampling.
|
||||
The last one is the DDQN or DDPG update, which is executed on GPU.
|
||||
We measure the time cost to correct all priorities of EM(capacity is 106). All data must be predicted by DDQN on GPU, it needs 150+ s. We can see that the update cost is very high.
|
||||
|
||||
同时笔者本人及导师在实验时也发现了同样的问题，PER对于目前稀疏奖励环境，理论上应该是有成效，但由于现阶段大家为了更快探索，更快收敛，不仅在环境感知层面做了不少trick，奖励函数也设计得越来越丰富，PER耗时长的缺点被无限放大，故而大家在选择经验回放池的时候尽可能考虑自己的实际情况，不要拿着Rainbow算法就开始魔改，效果可能会适得其反。
|
||||
## 参考文献
|
||||
1.[https://arxiv.org/pdf/1511.05952.pdf](https://arxiv.org/pdf/1511.05952.pdf)
|
||||
|
||||
2.[https://zhuanlan.zhihu.com/p/310630316](https://zhuanlan.zhihu.com/p/310630316)
|
||||
|
||||
3.[https://zhuanlan.zhihu.com/p/160186240](https://zhuanlan.zhihu.com/p/160186240)
|
||||
|
||||
4.[https://zhuanlan.zhihu.com/p/137880325](https://zhuanlan.zhihu.com/p/137880325)
|
||||
|
||||
5.[https://jaromiru.com/2016/11/07/lets-make-a-dqn-double-learning-and-prioritized-experience-replay/](https://jaromiru.com/2016/11/07/lets-make-a-dqn-double-learning-and-prioritized-experience-replay/)
|
||||
|
||||
6.[https://www.mdpi.com/2076-3417/10/19/6925/pdf](https://www.mdpi.com/2076-3417/10/19/6925/pdf)
|
||||
|
||||
7.[蘑菇书EasyRL](https://gitcode.net/mirrors/datawhalechina/easy-rl?utm_source=csdn_github_accelerator)
|
||||
|
||||
## 个人简介
|
||||
|
||||
李成阳
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,306 @@
|
||||
## JOYRL论文阅读<Rainbow: Combining Improvements in Deep Reinforcement Learning>
|
||||
|
||||
作者：Hessel, M., Modayil, J., Van Hasselt, H., Schaul, T., Ostrovski, G., Dabney, W., ... & Silver, D.
|
||||
|
||||
实验室：Google DeepMind
|
||||
|
||||
论文地址：https://arxiv.org/pdf/1710.02298
|
||||
|
||||
发表： In *Thirty-second AAAI conference on artificial intelligence*.
|
||||
|
||||
## 1 摘要
|
||||
|
||||
### 1.1 摘要--背景及问题
|
||||
|
||||
从DQN<sup><a href="#ref1">1</a></sup>推导过程中发现依旧存在很多问题，常见的改进措施Double DQN<sup><a href="#ref1">2</a></sup>、Dueling DQN<sup><a href="#ref1">3</a></sup>、Prioritized replay<sup><a href="#ref1">4</a></sup>、Multi-step<sup><a href="#ref1">5</a></sup>、Distributional RL<sup><a href="#ref1">6</a></sup>、Noisy Net<sup><a href="#ref1">7</a></sup>等方法，这些方法并不是完全独立，比如在Dueling中其实已经将Double DQN和Prioritized replay结合起来。
|
||||
|
||||
### 1.2 摘要--方法
|
||||
|
||||
本文希望将上述六种DQN方法结合经验融合在一起，来得到一个更好的网络。
|
||||
|
||||
### 1.3 摘要--贡献
|
||||
|
||||
1. 成为Atari 2600中SOTA(State-of-the-art)
|
||||
2. 我们还提供详细的消融研究的结果，该研究结果显示了每个组件对整体性能的贡献。
|
||||
|
||||
## 2 问题背景
|
||||
|
||||
### 2.1 RL problem & 记号
|
||||
|
||||
强化学习希望一个具有动作(Action)的智能体(Agent) 在与环境(Environment)交互的过程可以最大化奖励(Reward)，在这个过程中并不会直接监督式的学习。这里分享另外一种定义:
|
||||
|
||||
> 一、Mathematical formalism for learning- based decision making
|
||||
>
|
||||
> 二、Approach for learning decision-making and control from experience
|
||||
|
||||
**MDP (Markov Decision Process) $\{S,A,T,r,\gamma\}$ **
|
||||
|
||||
在不同的时间步下$t=0,1,2,..$，环境状态$S_t$提供给智能体一个观测信息$O_t$，通常我们会认为是完全观测(即$S_t=O_t$)，同时智能体根据观测信息做出动作$A_t$，之后环境给出下一个奖励$R_{t+1}$，奖励的折扣$\gamma_{t+1}$以及更新状态为$S_{t+1}$
|
||||
|
||||
|
||||
|
||||
在这个过程通常$S,A$是有限的情况，对于环境来说状态转移 (Stochastic transition function)、奖励方程包括
|
||||
|
||||
$$T(s,a,s')=P[S_{t+1=s'}|S_t=s,A_t=a]$$
|
||||
|
||||
$$r(s,a)=E[R_{t+1}|S_t=s,A_t=a]$$
|
||||
|
||||
对于智能体来说，根据状态$S_t$（或者完全观测下的观测$O_t$)得到得到动作$A_t$来自于策略$\pi$（Policy)，在序列决策中我们的目标是最大化某个状态采取某个动作的折扣奖励之和
|
||||
|
||||
$$P(A_t=a)=\pi_{\theta}[A_t=a|S_t=s]$$
|
||||
|
||||
$$max G_t=\Sigma_{k=0}^{\infty}r_t^{k}R_{t+k+1}$$
|
||||
|
||||
我们在利用算法进行梯度提升通常会经过三个步骤：
|
||||
|
||||
1. 生成样本
|
||||
2. 评估模型或者是计算回报
|
||||
3. 提升策略
|
||||
|
||||
### 2.2 Policy Gradient：直接提升策略
|
||||
|
||||
为了最大化策略的回报，我们可以直接对$G_t$最大化（即REINFRORCEMENT算法）
|
||||
|
||||
|
||||
|
||||
我们可以利用Baseline、N-steps、Discount、Importance sampling等技巧对算法进行改进。
|
||||
|
||||
### 2.3 **Actor-Crtic方法**：评估汇报(Estimate return)与提升策略分开
|
||||
|
||||
也可以引入新的状态价值函数$V^{\pi}(s)$来结合拟合的方式计算$G_t$之后最大化(A3C)，也可以直接利用 $V^{\pi}(s)$和动作状态价值函数$Q^{\pi}(s,a)$来进行基于价值函数的学习方法。
|
||||
|
||||
$$V^{\pi}(s)=E_{\pi}[G_t|S_t=s]$$
|
||||
|
||||
$$Q^{\pi}(s,a)=E_\pi[G_t|S_t=s,A_t=a]$$
|
||||
|
||||
|
||||
|
||||
我们可以利用回放池(Replay buffer)、神经网络来学习降低策略梯度中的方差。
|
||||
|
||||
### 2.4 Value-based method 抛弃策略
|
||||
|
||||
Policy iteration->Value iteration->Q learning
|
||||
|
||||
首先从策略迭代与价值迭代说起，[参考链接](https://hrl.boyuai.com/chapter/1/%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92%E7%AE%97%E6%B3%95)可以看作是利用动态规划的方式反应强化学习的过程，两者的区别在于反应的是贝尔曼期望还是贝尔曼最优。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
在基于价值学习算法的过程中，优点是我们只需要一个经验回放池，只需要$(s,a,s',r)$而不是需要完整的决策序列。我们通常会引入随机探索（Exploration）的概念，常见的包括$\epsilon-Greedy$的方法，在一定概率下选择非策略产生的动作。
|
||||
|
||||
|
||||
|
||||
在价值迭代的基础上，我们可以抛弃对$V(s)$的学习，而只是记录$Q(s,a)$; Q-iteration algorithm (或者$Q-learning$)的过程如下图所示
|
||||
|
||||
|
||||
|
||||
### 2.5 DQN推导
|
||||
|
||||
在上述我们认识对于MDP目标，从显式表达策略，到结合状态价值再到之后的完全使用价值函数来使用学习的方法，我们仍然没有解决的问题包括
|
||||
|
||||
1. 状态-动作空间的连续性
|
||||
2. 在状态空间和动作空间纬度大的时候无法准确刻画 状态-动作价值
|
||||
|
||||
随着神经网络的发展，我们希望利用网络拟合的方式来解决上述问题，同时每一步利用$\epsilon-Greedy$的方式来探索回放池中的经验，并利用梯度下降等方法最小化价值函数表达的回报
|
||||
|
||||
$$min (R_{t+1}+\gamma_{t+1}max_{a'}(S_{t+1},a')-q_{\theta}(S_t,A_t))^2$$
|
||||
|
||||
* 1 初始化大小为$N$的经验回放池 (PS：注意有大小限制)
|
||||
* 2 用相同随机的网络参数初始化 $Q_{\theta}(s,a)$ 与目标网络 $Q_{\theta'}(s,a)$
|
||||
* 3 FOR 回合 = 1，N DO：
|
||||
* 4 获取环境初始状态 $s_1$
|
||||
* 5 FOR 时间步 = 1，T DO：
|
||||
* 6 根据当前网络$a_t=max_a Q_{\theta}(s,a)$结合$\epsilon-Greedy$方法来得到$a_t$（PS：注意这一步动作的确定隐含之后DQN回报偏大的特点）
|
||||
* 7 执行动作$a_t$,获取$r_t$,环境状态变为$s_{t+1}$
|
||||
* 8 存储上述采样信息到经验回放池
|
||||
* 9 if 经验回放池数目足够：
|
||||
* 10 采样batchsize个样本$\{s_t^i,a_t^i,r_t^i,s_{t+1}^i\}$
|
||||
* 11 计算目标值$y^i_t=r^i_t+\gamma*max_aQ_{\hat \theta}(s^i_{t+1},a^i_t)$
|
||||
* 12 最小化损失函数$L=\frac{1}{N}(y_t^i-Q_{\theta}(s_t^i,a_t^i))^2$
|
||||
* 13 更新网络参数
|
||||
* 14 END FOR
|
||||
* 15 更新目标网络参数
|
||||
* 16 END FOR
|
||||
|
||||
|
||||
|
||||
其中非常有趣的技巧包括：
|
||||
|
||||
1. 经验回放(Experience replay)与随机探索；这一部分主要是为了提高样本采样效率，同时降低后续梯度下降中样本的相关性。
|
||||
2. 目标网络(Target network)；由于TD误差在策略改变过程中也会改变，因此造成神经网络拟合过程的不稳定性，因此构建新的目标网络，在每次迭代过程中暂时固定，在回合结合后更新参数，这样需要两层Q网络。
|
||||
|
||||
[相关代码实现](https://paperswithcode.com/paper/playing-atari-with-deep-reinforcement)
|
||||
|
||||
|
||||
|
||||
## 3 DQN改进
|
||||
|
||||
虽然DQN成功让强化学习在某些方面超过人类，但是依旧有这许多限制。
|
||||
|
||||
### 3.1 改进1：Double Q- Learning
|
||||
|
||||
在DQN中会有估计值过高的情况，证明如下：
|
||||
|
||||
$$target-value:y^i_t=r^i_t+\gamma max_{a_{t+1}^i}Q_{\hat \theta}(S^i_{t+1},a^i_{t+1})$$
|
||||
|
||||
$$max_{a_{t+1}^i}Q_{\hat \theta}(S^i_{t+1},a^i_{t+1})=Q_{\hat \theta}(s_{t+1}^i,argmax_{a_{t+1}^i}Q_{\hat \theta}(s_{t+1}^i,a_{t+1}^i))$$
|
||||
|
||||
根据期望公式
|
||||
|
||||
$$E[max(X1,X2)]>max(E(X1),E(X2))$$
|
||||
|
||||
|
||||
|
||||
我们通过证明发现估计值较大的原因是因为我在模型选择行为和计算Q值使用同一个网络，如果降低行为选择和Q值计算的相关性就可以降低高估，因此直觉的我们可以设计两个网络
|
||||
|
||||
$$Q_{\theta_A}(s,a)=r+\gamma Q_{\theta_b}(s',a')$$
|
||||
|
||||
$$Q_{\theta_B}(s,a)=r+\gamma Q_{\theta_a}(s',a')$$
|
||||
|
||||
我们的确可以新加一个网络，但是会增加学习难度，需要重新设计架构。所以为什么不直接使用$Q_{\theta}(s,a)$作为行为的估计？
|
||||
|
||||
$$(target\_value\_double\_Q-learning):y^i_t=r^i_t+\gamma Q_{\hat \theta}(s^i_{t+1},argmax_{r^i_{t+1}Q_{\theta}}(s^i_{t+1},a^i_{t+1}))$$
|
||||
|
||||
### 3.2 改进2：Prioritized replay
|
||||
|
||||
在DQN学习中为高效利用$(s,a,r,s)$样本，我们会使用经验回放的方式来存储一定规模的样本，在梯度下降的时候通常是从经验回放中均匀采样（Uniformly sampling）来进行学习，但是我们依旧会存在两个问题：
|
||||
|
||||
1. 依旧没有完全解决数据之间独立同分布的假设
|
||||
2. 容易忘记一些罕见的、重要的经验数据
|
||||
|
||||
在该论文中作者首先制定指标“TD-error”作为衡量$(s_t^i,a_t^i,r_t^i,s^i_{t+1})$的信息量大小，作为采样的优先级，同时利用随机优先级采样、偏置和重要性采样等方式来避免贪心的问题。优先级的获取有3.2.1和3.2.2两种方式
|
||||
|
||||
$$(随机采样)P(i)=\frac{p_i^\alpha}{\Sigma_kP_k^\alpha}$$
|
||||
|
||||
### 3.2.1 比例优先级（Proportional prioritization）
|
||||
|
||||
$$P_i=|\sigma_i|+\epsilon$$
|
||||
|
||||
### 3.2.2 基于排名的优先级(Rank-based prioritization)
|
||||
|
||||
$$P_i=\frac{1}{rank(i)}$$；优点可以保证线性性质，对异常值不敏感。
|
||||
|
||||
上述两种是不同得到重要性的方式；在实现时候采用Sum-tree的数据结构降低算法复杂程度。在采样中考虑重要性采样(Importance sampling)，并由此来进行热偏置(Annealing the bias）来修正误差
|
||||
|
||||
$$w_j=(\frac{1}{N}*\frac{1}{P(i)})^\beta$$
|
||||
|
||||
|
||||
|
||||
### 3.3 改进3：Dueling networks
|
||||
|
||||
Dueling DQN是一种针对基于价值函数的强化学习的网络结构设计，其并不直接输出状态动作价值函数，而是输出状态价值函数与动作状态优势函数，因为通常会共用前几层的卷积参数，在后面则是状态价值函数与优势函数各自的参数。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
### 3.4 改进4：Multi-step learning
|
||||
|
||||
在对状态动作函数的优势估计时候，通常我们会分为蒙特卡洛方法与Bootstrap(或者是Actor- critic内的C)的方法
|
||||
|
||||
$$(MC-sampling)A_t=\Sigma_{k=0}^{\infty}\gamma_t^{k}（R_{t+k+1}-b)$$
|
||||
|
||||
$$(bootstrap-sampling)G_t=r_{t}+\gamma*V(s_{t+1})-V(s_t)$$
|
||||
|
||||
前者方法偏差低但是方差较大；后者方差低但是有偏。因此结合两者我们通常会有Multi-step target的方法。
|
||||
|
||||
|
||||
|
||||
同样的也可以用在DQN中对于状态动作价值函数的估计：
|
||||
|
||||
$$R_t^{n}=\Sigma_{k=0}^{n-1}\gamma_t^{k}R_{t+k+1}$$
|
||||
|
||||
更新之后的损失函数为
|
||||
|
||||
$$(R_t^{n}+\gamma_t^nmax_{a'}Q_{\hat \theta}(S_{t+n},a')-Q_\theta(S_t,A_t))^2$$
|
||||
|
||||
### 3.5 改进5：Distributional RL
|
||||
|
||||
在基于价值函数的学习中我们通常是返回一个期望或者最大值而丢失很多其他信息，因此Distributional RL尝试利用其分布而不是单个值来进行强化学习。首先本文尝试将价值函数范围$[V_{min},V_{max}]$划分为N个各自来估计价值函数，利用Boltzmann分布表示价值函数的分布，同时利用投影的操作
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
由此对于分布拟合可以划分为交叉熵的形式，算法流程
|
||||
|
||||
|
||||
|
||||
### 3.6 改进6：Noisy Nets
|
||||
|
||||
在Q- learning或者是DQN中，我们的轨迹并不是完全采样的，而是与我们的探索策略相关，最原本的是$\epsilon-Greedy$策略，这里提出一种NoisyNet来对参数增加噪声来增加模型的探索能力
|
||||
|
||||
$$y=(Wx+b)+(b_{noisy}\odot\epsilon^b+W_{noisy}\odot\epsilon^w)x$$
|
||||
|
||||
噪声的生成可以分为Independent Gaussian noise；Factorised Gaussian noise两种方式。
|
||||
|
||||
|
||||
|
||||
### 3.7 融合上述策略
|
||||
|
||||
首先将（改进5:Distributional RL）中的损失函数更换称为（改进4:Multi-step learning），并利用（改进1--Double Q- Learning）计算新的目标值
|
||||
|
||||
$$d_t^n=(R_t^n+r_t^nz,p_\hat\theta(S_{t+n},a^*_{t+n}))$$
|
||||
|
||||
损失函数为
|
||||
|
||||
$$D_{KL}(\Phi_zd_t^n||d_t)$$
|
||||
|
||||
同时在采样过程中我们通常会减少TD-error，而在本文中我们的损失函数为KL损失，因此我们的（改进2：Prioritized replay）中的优先级定义为
|
||||
|
||||
$$p_t\propto (D_{KL}(\Phi_zd_t^n||d_t))^w$$
|
||||
|
||||
同时改变（改进3: Dueling networks）由接受期望转向接受价值函数分布，最后更改所有的线性层更换为（改进6：Noisy Nets）
|
||||
|
||||
$$p_\theta(s,a)^i=\frac{exp(v^i_\eta(\phi)+a^i_\psi(\phi,a)-\hat a_\psi^i(s))}{\Sigma_j exp(v^j_\eta(\phi)+a^j_\psi(\phi,a)-\hat a_\psi^j(s)) }$$
|
||||
|
||||
## 4 实验
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
## 5 总结
|
||||
|
||||
### 5.1 结论
|
||||
|
||||
1. Rainbow相比较其他现有的算法要更好，速度也会更快
|
||||
2. 在消融实验中；我们会发现（改进2：Prioritized replay）与（改进4:Multi-step learning）会造成结果中位数大幅度下降;(改进5:Distributional RL)在最开始表现良好，但是最终结果表现较差；同时（改进6：Noisy Nets）通常会有更好的中位数表现，同时由于本次状态中通常是underestimate的，所以（改进1--Double Q- Learning）效果并不显著，（改进3: Dueling networks）提升幅度不大。
|
||||
|
||||
### 5.2 讨论
|
||||
|
||||
作者在最后总结他们的工作，主要是从Value- based的Q-learning方法集合中寻找，而没有考虑Purely policy- based的算法（比如TRPO)，本文从网络探索、网络初始化、数据使用、损失或函数等方面进行集合，与之相对应的同样有很多工作，未来还可以用很多其他的方法。但是
|
||||
|
||||
> In general, we believe that exposing the real game to the agent is a promising direction for future research.
|
||||
|
||||
### 5.3 个人感悟
|
||||
|
||||
这篇论文的观点很直接，在实际实现的过程中作者做了很多Dirty work，尝试过很多次，并最终证明集成的方式是有效的，以及分析哪些技巧是有效的、哪些技巧是欠佳的，工作量非常大！
|
||||
|
||||
|
||||
|
||||
【1】<span name = "DQN">[Mnih, V., Kavukcuoglu, K., Silver, D., Graves, A., Antonoglou, I., Wierstra, D., & Riedmiller, M. (2013). Playing atari with deep reinforcement learning. *arXiv preprint arXiv:1312.5602*.](https://arxiv.org/abs/1312.5602)</span>
|
||||
|
||||
【2】<span name = "DDQN">[Van Hasselt, H., Guez, A., & Silver, D. (2016, March). Deep reinforcement learning with double q-learning. In *Proceedings of the AAAI conference on artificial intelligence* (Vol. 30, No. 1).](http://arxiv.org/abs/1509.06461)</span>
|
||||
|
||||
【3】 <span name = "Prioritized experience replay"> [Schaul, T., Quan, J., Antonoglou, I., & Silver, D. (2015). Prioritized experience replay. *arXiv preprint arXiv:1511.05952*.](https://arxiv.org/abs/1511.05952)</span>
|
||||
|
||||
【4】<span name = "Multistep">[Multi Step Learning](https://www.cs.mcgill.ca/~dprecup/courses/RL/Lectures/8-multistep-2019.pdf)</span>
|
||||
|
||||
【5】<span name = "Dueling">[Wang, Z., Schaul, T., Hessel, M., Hasselt, H., Lanctot, M., & Freitas, N. (2016, June). Dueling network architectures for deep reinforcement learning. In *International conference on machine learning* (pp. 1995-2003). PMLR.](https://arxiv.org/abs/1511.06581)</span>
|
||||
|
||||
【6】<span name = "Distributional">[Bellemare, M. G., Dabney, W., & Munos, R. (2017, July). A distributional perspective on reinforcement learning. In *International Conference on Machine Learning* (pp. 449-458). PMLR.](https://arxiv.org/pdf/1707.06887.pdf)</span>
|
||||
|
||||
【7】<span name = "NoisyDQN">[Fortunato, M., Azar, M. G., Piot, B., Menick, J., Osband, I., Graves, A., ... & Legg, S. (2017). Noisy networks for exploration. *arXiv preprint arXiv:1706.10295*.](https://arxiv.org/abs/1706.10295)</span>
|
||||
|
||||
### 自我介绍
|
||||
|
||||
非典型INFJ，一枚普通985的交通信息方向2022级硕士生，主要研究方向为交通数据分析、组合优化等，在学习的路上希望自己可以保持“求知若饥，虚心若愚”。可以在blog.tjdata.site找到我。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user