diff --git a/docs/ch8/main.md b/docs/ch8/main.md index 3e79948..dcd1052 100644 --- a/docs/ch8/main.md +++ b/docs/ch8/main.md @@ -85,35 +85,219 @@ $\qquad$ 总的来讲，$\text{Dueling DQN}$ 算法在某些情况下相对于 $ ## Noisy DQN 算法 -Noisy DQN 算法③ 也是通过优化网络结构的方法来提升 DQN 算法的性能，但与 Dueling 算法不同的是，它的目的并不是为了提高 $Q$ 值的估计，而是增强网络的探索能力。 +$\qquad$ $\text{Noisy DQN}$ 算法③ 也是通过优化网络结构的方法来提升 DQN 算法的性能，但与 Dueling 算法不同的是，它的目的并不是为了提高 $Q$ 值的估计，而是增强网络的探索能力。 -> ③ 论文链接：https://arxiv.org/abs/1706.10295 +> ③ Fortunato M , Azar M G , Piot B ,et al.Noisy Networks for Exploration[J]. 2017.DOI:10.48550/arXiv.1706.10295. -从 Q-learning 算法开始，我们就讲到了探索策略以及探索-利用窘境的问题，常见的 $\varepsilon-greedy$ 策略是从智能体与环境的交互过程改善探索能力，以避免陷入局部最优解。而在深度强化学习中，由于引入了深度学习，深度学习本身也会因为网络模型限制或者梯度下降方法陷入局部最优解问题。也就是说，深度强化学习既要考虑与环境交互过程中的探索能力，也要考虑深度模型本身的探索能力，从而尽量避免陷入局部最优解的困境之中，这也是为什么经常有人会说强化学习比深度学习更难“炼丹”的原因之一。 +$\qquad$ 从 $\text{Q-learning}$ 算法开始，我们就讲到了探索-利用平衡的问题，常见的 $\varepsilon-greedy$ 策略是从智能体与环境的交互过程改善探索能力，以避免陷入局部最优解。而在深度强化学习中，由于引入了深度学习，深度学习本身也会因为网络模型限制或者梯度下降方法陷入局部最优解问题。也就是说，深度强化学习既要考虑与环境交互过程中的探索能力，也要考虑深度模型本身的探索能力，从而尽量避免陷入局部最优解的困境之中，这也是为什么经常有人会说强化学习比深度学习更难“炼丹”的原因之一。 -回归正题，Noisy DQN 算法其实是在 DQN 算法基础上在神经网络中引入了噪声层来提高网络性能的，即将随机性应用到神经网络中的参数或者说权重，增加了 $Q$ 网络对于状态和动作空间的探索能力，从而提高收敛速度和稳定性。在实践上也比较简单，就是通过添加随机性参数到神经网络的线性层，对应的 $Q$ 值则可以表示为 $Q_{\theta+\epsilon}$，注意不要把这里的 $\epsilon$ 跟 $\varepsilon-greedy$ 策略中的 $\varepsilon$ 混淆了。虽然都叫做 epsilon，但这里 $\epsilon$ 是由高斯分布生成的总体分类噪声参数。 +$\qquad$ 回归正题，$\text{Noisy DQN}$ 算法其实是在 $\text{DQN}$ 算法基础上在神经网络中引入了噪声层来提高网络性能的，即将随机性应用到神经网络中的参数或者说权重，增加了 $Q$ 网络对于状态和动作空间的探索能力，从而提高收敛速度和稳定性。在实践上也比较简单，就是通过添加随机性参数到神经网络的线性层，对应的 $Q$ 值则可以表示为 $Q_{\theta+\epsilon}$，注意不要把这里的 $\epsilon$ 跟 $\varepsilon-greedy$ 策略中的 $\varepsilon$ 混淆了。虽然都叫做 $\epsilon$ ，但这里 $\epsilon$ 是由高斯分布生成的总体分类噪声参数。 -在实战中，我们首先可以定义引入了噪声层的线性层，如下： +$\qquad$ 其实在网络模型中增加噪声层是一种比较泛用的做法，而不只是用在 $\text{DQN}$ 算法中，具体做法读者可以参考后面的实战内容。 + + +## PER DQN 算法 + +$\qquad$ 在 $\text{DQN}$ 算法章节中我们讲到经验回放，从另一个角度来说也是为了优化深度网络中梯度下降的方式，或者说网络参数更新的方式。在本节要讲的 $\text{PER DQN}$ 算法④中，进一步优化了经验回放的设计从而提高模型的收敛能力和鲁棒性。PER 可以翻译为优先经验回放（$\text{prioritized experience replay}$），跟数据结构中优先队列与普通队列一样，会在采样过程中赋予经验回放中样本的优先级。 + +> ④ Schaul T , Quan J , Antonoglou I ,et al.Prioritized Experience Replay[J].Computer Science, 2015.DOI:10.48550/arXiv.1511.05952. + +$\qquad$ 具体以什么为依据来为经验回放中的样本赋予不同优先级呢？答案是 $\text{TD}$ 误差。$\text{TD}$ 误差最开始我们是在时序差分方法的提到的，广义的定义是值函数（包括状态价值函数和动作价值函数）的估计值与实际值之差，在 $\text{DQN}$ 算法中就是目标网络计算的 $Q$ 值和策略网络（当前网络）计算的 $Q$ 值之差，也就是 $\text{DQN}$ 网络中损失函数的主要构成部分。 + +$\qquad$ 我们每次从经验回访中取出一个批量的样本，进而计算的 $\text{TD}$ 误差一般是不同的，对于 $\text{DQN}$ 网络反向传播的作用也是不同的。**TD误差越大，损失函数的值也越大，对于反向传播的作用也就越大。** 这样一来如果 $\text{TD}$ 误差较大的样本更容易被采到的话，那么我们的算法也会更加容易收敛。因此我们只需要设计一个经验回放，根据经验回放中的每个样本计算出的TD误差赋予对应的优先级，然后在采样的时候取出优先级较大的样本。 + +$\qquad$ 原理听上去比较简单，但具体如何实现呢？在实践中，我们通常用 SumTree 这样的二叉树结构来实现。这里建议没有了解过数据结构或者二叉树的读者先花个十几分钟的时间快速了解一下二叉树的基本概念，比如根节点、叶节点、父节点与子节点等等。 + +$\qquad$ 如图 $\text{8-3}$ 所示，每个父节点的值等于左右两个子节点值之和。在强化学习中，所有的样本只保存在最下面的叶子节点中，并且除了保存样本数据之外，还会保存对应的优先级，即对应叶子节点中的值（例如图中的 $\text{31,13,14}$ 以及 $8$ 等，也对应样本的 $\text{TD}$ 误差）。并且根据叶子节点的值，我们从 $0$ 开始依次划分采样区间。然后在采样中，例如这里根节点值为 $66$ ，那么我们就可以在 $[0,66)$ 这个区间均匀采样，采样到的值落在哪个区间中，就说明对应的样本就是我们要采样的样本。例如我们采样到了 $25$ 这个值，即对应区间 $[0,31)$,那么我们就采样到了第一个叶子节点对应的样本。注意到，第一个样本对应的区间也是最长的，这意味着第一个样本的优先级最高，也就是 $\text{TD}$ 误差最大，反之第四个样本的区间最短，优先级也最低。这样一来，我们就可以通过采样来实现优先经验回放的功能。 + +
+ +
+
图 $\text{8-3}$ $\text{SumTree}$ 结构
+ +$\qquad$ 每个叶节点的值就是对应样本的 $\text{TD}$ 误差（例如途中的）。我们可以通过根节点的值来计算出每个样本的 $\text{TD}$ 误差占所有样本 $\text{TD}$ 误差的比例，这样就可以根据比例来采样样本。在实际的实现中，我们可以将每个叶节点的值设置为一个元组，其中包含样本的 $\text{TD}$ 误差和样本的索引，这样就可以通过索引来找到对应的样本。具体如何用 $\text{Python}$ 类来实现 $\text{SumTree}$ 结构，读者可以参考后面的实战内容。 + + + +$\qquad$ 尽管 $\text{SumTree}$ 结构可以实现优先经验回放的功能。然而直接使用 $\text{TD}$ 误差作为优先级存在一些问题。首先，考虑到算法效率问题，我们在每次更新时不会把经验回放中的所有样本都计算 $\text{TD}$ 误差并更新对应的优先级，而是只更新当前取到的一定批量的样本。这样一来，每次计算的 $\text{TD}$ 误差是对应之前的网络，而不是当前待更新的网络。换句话说，如果某批量样本的 $\text{TD}$ 误差较低，只能说明它们对于之前的网络来说“信息量”不大，但不能说明对当前的网络“信息量”不大，因此单纯根据 $\text{TD}$ 误差进行优先采样有可能会错过对当前网络“信息量”更大的样本。其次，被选中样本的 $\text{TD}$ 误差会在当前更新后下降，然后优先级会排到后面去，下次这些样本就不会被选中，这样来来回回都是那几个样本，很容易出现“旱的旱死，涝的涝死”的情况，导致过拟合。 + +$\qquad$ 为了解决上面提到的两个问题，我们首先引入**随机优先级采样**（ $\text{stochastic prioritization}$ ）的技巧。即在每次更新时，我们不再是直接采样 $\text{TD}$ 误差最大的样本，而是定义一个采样概率，如式 $\text{(8.7)}$ 所示。 + +$$ +\tag{8.7} +P(i) = \frac{p_i^\alpha}{\sum_k p_k^\alpha} +$$ + +$\qquad$ 其中，$p_i$ 是样本 $i$ 的优先级，$\alpha$ 是一个超参数，用于调节优先采样的程序，通常在 $(0,1)$ 的区间内。当 $\alpha=0$ 时，采样概率为均匀分布；当 $\alpha =1$ 时，采样概率为优先级的线性分布。同时，即使对于最低优先级的样本，我们也不希望它们的采样概率为 $0$ ，因此我们可以在优先级上加上一个常数 $\epsilon$，即式 $\text{(8.8)}$ 。 + +$$ +\tag{8.8} +p_i = |\delta_i| + \epsilon +$$ + +$\qquad$ 其中，$|\delta_i|$ 是样本 $i$ 的 $\text{TD}$ 误差。当然，我们也可以使用其他的优先级计算方式，如式 $\text{(8.9)}$ 所示。 + +$$ +\tag{8.9} +p_i = \frac{1}{rank(i)} +$$ + +$\qquad$ 其中 $rank(i)$ 是样本 $i$ 的优先级排名，这种方式也能保证每个样本的采样概率都不为 $0$ ，但在实践中，我们更倾向于直接增加一个常数 $\epsilon$ 的方式。 + +$\qquad$ 除了随机优先级采样之外，我们还引入了另外一个技巧，在讲解该技巧之前，我们需要简单了解一下**重要性采样**，这个概念在后面的 $\text{PPO}$ 算法也会用到，读者需要重点掌握。重要性采样（$\text{importance sampling}$ ）是一种用于估计某一分布性质的方法，它的基本思想是，我们可以通过与待估计分布不同的另一个分布中采样，然后通过采样样本的权重来估计待估计分布的性质，数学表达式如式 $\text{(8.10)}$ 所示。 + +$$ +\tag{8.10} +\begin{aligned} +\mathbb{E}_{x \sim p(x)}[f(x)] &= \int f(x) p(x) dx \\ +&= \int f(x) \frac{p(x)}{q(x)} q(x) dx \\ +&= \int f(x) \frac{p(x)}{q(x)} \frac{q(x)}{p(x)} p(x) dx \\ +&= \mathbb{E}_{x \sim q(x)}\left[\frac{p(x)}{q(x)} f(x)\right] +\end{aligned} +$$ + +$\qquad$ 其中 $p(x)$ 是待估计分布，$q(x)$ 是采样分布，$f(x)$ 是待估计分布的性质。在前面我们讲到，每次计算的 $\text{TD}$ 误差是对应之前的网络，而不是当前待更新的网络。也就是说，我们已经从之前的网络中采样了一批样本，也就是 $q(x)$ 已知，然后只要找到之前网络分布与当前网络分布之前的权重 $\frac{p(x)}{q(x)}$，就可以利用重要性采样来估计出当前网络的性质。我们可以定义权重为式 $\text{(8.11)}$ 。 + +$$ +\tag{8.11} +w_i = \left(\frac{1}{N} \frac{1}{P(i)}\right)^\beta +$$ + +其中，$N$ 是经验回放中的样本数量，$P(i)$ 是样本 $i$ 的采样概率。同时，为了避免出现权重过大或过小的情况，我们可以对权重进行归一化处理，如式 $\text{(8.12)}$ 所示。 + +$$ +\tag{8.12} +w_i = \frac{\left(N*P(i)\right)^{-\beta}}{\max_j (w_j)} +$$ + +$\qquad$ 注意到，我们引入了一个超参数 $\beta$，用于调节重要性采样的程度，这个技术叫做 **热偏置**。当 $\beta = 0$ 时，重要性采样的权重为 1，即不考虑重要性采样；当 $\beta = 1$ 时，重要性采样的权重为 $w_i$，即完全考虑重要性采样。在实践中，我们希望 $\beta$ 从 0 开始，随着训练步数的增加而逐渐增加，以便更好地利用重要性采样，这就是热偏置（Annealing The Bias）的思想。数学表达式如式 $\text{(8.13)}$ 所示。 + +$$ +\tag{8.13} +\beta = \min(1, \beta + \beta_{\text{step}}) +$$ + +$\qquad$ 其中，$\beta_{\text{step}}$ 是每个训练步数对应的 $\beta$ 的增量。在实践中，我们可以将 $\beta_{\text{step}}$ 设置为一个很小的常数，如 $0.0001$。这样一来，我们就可以在训练刚开始时，使用随机优先级采样，以便更快地收敛；在训练后期，使用重要性采样，以便更好地利用经验回放中的样本。 + +结合上面的优先级采样和重要性采样，我们可以基于 SumTree 实现一个带有优先级的经验回放，代码如下： + + + + + +## C51 算法 + +分布式 DQN 算法，即 Distributed DQN，有时也会看到它也叫 Categorical DQN 这个名字，但最常见的名字是 C51 算法⑤ 。该算法跟 PER 算法一样，是从不同的角度改进强化学习算法，而不单单指 DQN 算法，而是能适用于任何基于 Q-learning 的强化学习算法。该算法的核心思想是将传统 DQN 算法中的值函数 $Q(s,a)$ 换成了值分布 $Z(x,a)$，即将值函数的输出从一个数值变成了一个分布，这样就能更好地处理值函数估计不准确以及离散动作空间的问题。 + +> ⑤ 论文链接：https://arxiv.org/abs/1707.06887 + +在之前讲到的经典强化学习算法中我们优化的其实是值分布的均值，也就是 $Q$ 函数，但实际上由于状态转移的随机性、函数近似等原因，智能体与环境之间也存在着随机性，这也导致了最终累积的回报也会是一个随机变量，使用一个确定的均值会忽略整个分布所提供的信息。。因此，我们可以将值函数 $Q$ 看成是一个随机变量，它的期望值就是 $Q$ 函数，而它的方差就是 $Q$ 函数的不确定性，公式表示如下： + +$$ +Q^\pi(x, a):=\mathbb{E} Z^\pi(x, a)=\mathbb{E}\left[\sum_{t=0}^{\infty} \gamma^t R\left(x_t, a_t\right)\right] +$$ + +其中状态分布 $x_t \sim P\left(\cdot \mid x_{t-1}, a_{t-1}\right), a_t \sim \pi\left(\cdot \mid x_t\right), x_0=x, a_0=a \text {. }$ + +## Rainbow DQN 算法 + +## 实战：Double DQN 算法 + +$\qquad$ 由于本章都是基于 $\text{DQN}$ 改进的算法，整体训练方式跟 $\text{DQN}$ 是一样的，也就是说伪代码基本都是一致的，因此不再赘述，只讲算法的改进部分。而 $\text{Double DQN}$ 算法跟 $\text{DQN}$ 算法的区别在于目标值的计算方式，如代码清单 $\text{8-1}$ 所示。 + +
+
代码清单 $\text{8-1}$ $\text{Double DQN}$目标值的计算
+
+ +```python +# 计算当前网络的Q值，即Q(s_t+1|a) +next_q_value_batch = self.policy_net(next_state_batch) +# 计算目标网络的Q值，即Q'(s_t+1|a) +next_target_value_batch = self.target_net(next_state_batch) +# 计算 Q'(s_t+1|a=argmax Q(s_t+1|a)) +next_target_q_value_batch = next_target_value_batch.gather(1, torch.max(next_q_value_batch, 1)[1].unsqueeze(1)) +``` + +$\qquad$ 最后与 $\text{DQN}$ 算法相同，可以得到 $\text{Double DQN}$ 算法在 $\text{CartPole}$ 环境下的训练结果，如图 $\text{8-5}$ 所示，完整的代码可以参考本书的代码仓库。 + +
+ +
+
图 $\text{8-5}$ $\text{CartPole}$ 环境 $\text{Double DQN}$ 算法训练曲线
+ +$\qquad$ 与 $\text{DQN}$ 算法的训练曲线对比可以看出，在实践上 $\text{Double DQN}$ 算法的效果并不一定比 $\text{DQN}$ 算法好，比如在这个环境下其收敛速度反而更慢了，因此读者需要多多实践才能摸索并体会到这些算法适合的场景。 + +## 实战：Dueling DQN 算法 + +$\qquad$ $\text{Dueling DQN}$ 算法主要是改了网络结构，其他地方跟 $\text{DQN}$ 是一模一样的，如代码清单 $\text{8-2}$ 所示。 + +
+
代码清单 $\text{8-2}$ $\text{Dueling DQN}$ 网络结构
+
+ +```python +class DuelingQNetwork(nn.Module): + def __init__(self, state_dim, action_dim,hidden_dim=128): + super(DuelingQNetwork, self).__init__() + # 隐藏层 + self.hidden_layer = nn.Sequential( + nn.Linear(state_dim, hidden_dim), + nn.ReLU() + ) + # 优势层 + self.advantage_layer = nn.Sequential( + nn.Linear(hidden_dim, hidden_dim), + nn.ReLU(), + nn.Linear(hidden_dim, action_dim) + ) + # 价值层 + self.value_layer = nn.Sequential( + nn.Linear(hidden_dim, hidden_dim), + nn.ReLU(), + nn.Linear(hidden_dim, 1) + ) + + def forward(self, state): + x = self.hidden_layer(state) + advantage = self.advantage_layer(x) + value = self.value_layer(x) + return value + advantage - advantage.mean() # Q(s,a) = V(s) + A(s,a) - mean(A(s,a)) +``` + +$\qquad$ 最后我们展示一下它在 $\text{CartPole}$ 环境下的训练结果，如图 $\text{8-6}$ 所示，完整的代码同样可以参考本书的代码仓库。 + +
+ +
+
图 $\text{8-5}$ $\text{CartPole}$ 环境 $\text{Dueling DQN}$ 算法训练曲线
+ +$\qquad$ 由于环境比较简单，暂时还看不出来 $\text{Dueling DQN}$ 算法的优势，但是在复杂的环境下，比如 $\text{Atari}$ 游戏中，$\text{Dueling DQN}$ 算法的效果就会比 $\text{DQN}$ 算法好很多，读者可以在 $\text{JoyRL}$ 仓库中找到更复杂环境下的训练结果便于更好地进行对比。 + +## 实战：Noisy DQN 算法 + +$\qquad$ $\text{Noisy DQN}$ 算法的核心思想是将 $\text{DQN}$ 算法中的线性层替换成带有噪声的线性层，如代码清单 $\text{8-3}$ 所示。 + +
+
代码清单 $\text{8-3}$ 带有噪声的线性层网络
+
```python class NoisyLinear(nn.Module): '''在Noisy DQN中用NoisyLinear层替换普通的nn.Linear层 ''' - def __init__(self, in_dim, out_dim, std_init=0.4): + def __init__(self, input_dim, output_dim, std_init=0.4): super(NoisyLinear, self).__init__() - - self.in_dim = in_dim - self.out_dim = out_dim + self.input_dim = input_dim + self.output_dim = output_dim self.std_init = std_init - - self.weight_mu = nn.Parameter(torch.empty(out_dim, in_dim)) - self.weight_sigma = nn.Parameter(torch.empty(out_dim, in_dim)) + self.weight_mu = nn.Parameter(torch.empty(output_dim, input_dim)) + self.weight_sigma = nn.Parameter(torch.empty(output_dim, input_dim)) # 将一个 tensor 注册成 buffer，使得这个 tensor 不被当做模型参数进行优化。 - self.register_buffer('weight_epsilon', torch.empty(out_dim, in_dim)) + self.register_buffer('weight_epsilon', torch.empty(output_dim, input_dim)) - self.bias_mu = nn.Parameter(torch.empty(out_dim)) - self.bias_sigma = nn.Parameter(torch.empty(out_dim)) - self.register_buffer('bias_epsilon', torch.empty(out_dim)) + self.bias_mu = nn.Parameter(torch.empty(output_dim)) + self.bias_sigma = nn.Parameter(torch.empty(output_dim)) + self.register_buffer('bias_epsilon', torch.empty(output_dim)) self.reset_parameters() # 初始化参数 self.reset_noise() # 重置噪声 @@ -128,17 +312,17 @@ class NoisyLinear(nn.Module): return F.linear(x, weight, bias) def reset_parameters(self): - mu_range = 1 / self.in_dim ** 0.5 + mu_range = 1 / self.input_dim ** 0.5 self.weight_mu.data.uniform_(-mu_range, mu_range) - self.weight_sigma.data.fill_(self.std_init / self.in_dim ** 0.5) + self.weight_sigma.data.fill_(self.std_init / self.input_dim ** 0.5) self.bias_mu.data.uniform_(-mu_range, mu_range) - self.bias_sigma.data.fill_(self.std_init / self.out_dim ** 0.5) + self.bias_sigma.data.fill_(self.std_init / self.output_dim ** 0.5) def reset_noise(self): - epsilon_in = self._scale_noise(self.in_dim) - epsilon_out = self._scale_noise(self.out_dim) + epsilon_in = self._scale_noise(self.input_dim) + epsilon_out = self._scale_noise(self.output_dim) self.weight_epsilon.copy_(epsilon_out.ger(epsilon_in)) - self.bias_epsilon.copy_(self._scale_noise(self.out_dim)) + self.bias_epsilon.copy_(self._scale_noise(self.output_dim)) def _scale_noise(self, size): x = torch.randn(size) @@ -146,7 +330,11 @@ class NoisyLinear(nn.Module): return x ``` -根据写好的 NoisyLinear 层，我们可以在 DQN 算法中将普通的线性层替换为 NoisyLinear 层，如下： +$\qquad$ 根据写好的 $\text{NoisyLinear}$ 层，我们可以在 $\text{DQN}$ 算法中将普通的线性层替换为 $\text{NoisyLinear}$ 层，如代码清单 $\text{8-4}$ 所示。 + +
+
代码清单 $\text{8-4}$ 带噪声层的全连接网络
+
```python class NoisyQNetwork(nn.Module): @@ -167,7 +355,11 @@ class NoisyQNetwork(nn.Module): self.noisy_fc3.reset_noise() ``` -注意在训练过程中，我们需要在每个 mini-batch 中重置噪声，更多细节请参考 JoyRL 源码。另外，我们可以直接利用 torchrl 模块中中封装好的 NoisyLinear 层来构建 Noisy Q 网络，跟我们自己定义的功能是一样的，如下： +$\qquad$ 注意在训练过程中，我们需要在每次更新后重置噪声，这样有助于提高训练的稳定性，更多细节请参考 $\text{JoyRL}$ 源码。另外，我们也可以直接利用 $\text{torchrl}$ 模块中中封装好的 $\text{NoisyLinear}$ 层来构建 $\text{Noisy Q}$ 网络，跟我们自己定义的功能是一样的，如代码清单 $\text{8-5}$ 所示。 + +
+
代码清单 $\text{8-5}$ 使用 $\text{torchrl}$ 模块构造的 $\text{Noisy Q}$ 网络
+
```python import torchrl @@ -189,26 +381,32 @@ class NoisyQNetwork(nn.Module): self.noisy_fc3.reset_noise() ``` -## PER DQN 算法 +$\qquad$ 同样我们展示一下它在 $\text{CartPole}$ 环境下的训练结果，如图 $\text{8-6}$ 所示。 -在 DQN 算法章节中我们讲到经验回放，从另一个角度来说也是为了优化深度网络中梯度下降的方式，或者说网络参数更新的方式。在本节要讲的 PER DQN 算法④中，进一步优化了经验回放的设计从而提高模型的收敛能力和鲁棒性。PER 英文全称为 Prioritized Experience Replay，即优先经验回放，跟数据结构中优先队列与普通队列一样，会在采样过程中赋予经验回放中样本的优先级。 +
+ +
+
图 $\text{8-6}$ $\text{CartPole}$ 环境 $\text{Noisy DQN}$ 算法训练曲线
+ +## 实战：PER DQN 算法 -> ④ 论文链接：https://arxiv.org/abs/1511.05952 +### 伪代码 -具体以什么为依据来为经验回放中的样本赋予不同优先级呢？答案是TD误差。TD误差最开始我们是在时序差分方法的提到的，广义的定义是值函数（包括状态价值函数和动作价值函数）的估计值与实际值之差，在 DQN 算法中就是目标网络计算的 $Q$ 值和策略网络（当前网络）计算的 $Q$ 值之差，也就是 DQN 网络中损失函数的主要构成部分。我们每次从经验回访中取出一个批量的样本，进而计算的TD误差一般是不同的，对于 DQN 网络反向传播的作用也是不同的。**TD误差越大，损失函数的值也越大，对于反向传播的作用也就越大。** 这样一来如果TD误差较大的样本更容易被采到的话，那么我们的算法也会更加容易收敛。因此我们只需要设计一个经验回放，根据经验回放中的每个样本计算出的TD误差赋予对应的优先级，然后在采样的时候取出优先级较大的样本。 +$\qquad$ $\text{PER DQN}$ 算法的核心看起来简单，就是把普通的经验回放改进成了优先级经验回放，但是实现起来却比较复杂，因为我们需要实现一个 $\text{SumTree}$ 结构，并且在模型更新的时候也需要一些额外的操作，因此我们先从伪代码开始，如图 $\text{8-7}$ 所示。 -原理听上去比较简单，但具体如何实现呢？在实践中，我们通常用 SumTree 这样的二叉树结构来实现。这里建议没有了解过数据结构或者二叉树的读者先花个十几分钟的时间快速了解一下二叉树的基本概念，比如根节点、叶节点、父节点与子节点等等。
- +
-
图 8.4 SumTree 结构
+
图 $\text{8-7}$ $\text{PER DQN}$ 伪代码
-如图 8.4 所示，每个父节点的值等于左右两个子节点值之和。在强化学习中，所有的样本只保存在最下面的叶子节点中，并且除了保存样本数据之外，还会保存对应的优先级，即对应叶子节点中的值（例如图中的31、13、14以及8等，也对应样本的 TD 误差）。并且根据叶子节点的值，我们从 $0$ 开始依次划分采样区间。然后在采样中，例如这里根节点值为 66，那么我们就可以在$[0,66)$这个区间均匀采样，采样到的值落在哪个区间中，就说明对应的样本就是我们要采样的样本。例如我们采样到了 $25$ 这个值，即对应区间 $[0,31)$,那么我们就采样到了第一个叶子节点对应的样本。注意到，第一个样本对应的区间也是最长的，这意味着第一个样本的优先级最高，也就是 TD 误差最大，反之第四个样本的区间最短，优先级也最低。这样一来，我们就可以通过采样来实现优先经验回放的功能。 +### SumTree 结构 -每个叶节点的值就是对应样本的 TD 误差（例如途中的）。我们可以通过根节点的值来计算出每个样本的 TD 误差占所有样本 TD 误差的比例，这样就可以根据比例来采样样本。在实际的实现中，我们可以将每个叶节点的值设置为一个元组，其中包含样本的 TD 误差和样本的索引，这样就可以通过索引来找到对应的样本。 +$\qquad$ 如代码清单 $\text{8-6}$ 所示，我们可以先实现 $\text{SumTree}$ 结构。 -基于以上原理，我们可以新建一个 Python 类来实现 SumTree 结构，代码如下： +
+
代码清单 $\text{8-6}$ $\text{SumTree}$ 结构
+
```python class SumTree: @@ -270,62 +468,15 @@ class SumTree: ''' return np.max(self.tree[self.capacity-1:self.capacity+self.write_idx-1]) ``` -其中，除了需要存放各个节点的值（`tree`）之外，我们需要定义要给`data`来存放叶子节点的样本。此外，`add` 函数用于添加一个样本到叶子节点，并更新其父节点的优先级；`update` 函数用于更新叶子节点的优先级，并更新其父节点的优先级；`get_leaf` 函数用于根据优先级的值采样对应区间的叶子节点样本；`get_data` 函数用于根据索引获取对应的样本；`total` 函数用于返回所有样本的优先级之和，即根节点的值；`max_prior` 函数用于返回所有样本的最大优先级。 +$\qquad$ 其中，除了需要存放各个节点的值（$\text{tree}$）之外，我们需要定义要给 $\text{data}$ 来存放叶子节点的样本。此外，$\text{add}$ 函数用于添加一个样本到叶子节点，并更新其父节点的优先级；$\text{update}$ 函数用于更新叶子节点的优先级，并更新其父节点的优先级；$\text{get_leaf}$ 函数用于根据优先级的值采样对应区间的叶子节点样本；$\text{get_data}$ 函数用于根据索引获取对应的样本；$\text{total}$ 函数用于返回所有样本的优先级之和，即根节点的值；$\text{max_prior}$ 函数用于返回所有样本的最大优先级。 -基于以上的 SumTree 结构，我们可以实现优先经验回放的功能。然而，论文原作者认为，直接使用 TD 误差作为优先级存在一些问题。首先，考虑到算法效率问题，我们在每次更新时不会把经验回放中的所有样本都计算 TD 误差并更新对应的优先级，而是只更新当前取到的一定批量的样本。这样一来，每次计算的 TD 误差是对应之前的网络，而不是当前待更新的网络。换句话说，如果某批量样本的 TD 误差较低，只能说明它们对于之前的网络来说“信息量”不大，但不能说明对当前的网络“信息量”不大，因此单纯根据 TD 误差进行优先采样有可能会错过对当前网络“信息量”更大的样本。其次，被选中样本的 TD 误差会在当前更新后下降，然后优先级会排到后面去，下次这些样本就不会被选中，这样来来回回都是那几个样本，很容易出现“旱的旱死，涝的涝死”的情况，导致过拟合。 +### 优先级经验回放 -**随机优先级采样**。为了解决上面提到的两个问题，我们首先引入随机优先级采样（Stochastic Prioritization）的技巧。即在每次更新时，我们不再是直接采样 TD 误差最大的样本，而是定义一个采样概率，如下： +$\qquad$ 基于 $\text{SumTree}$ 结构，并结合优先级采样和重要性采样的技巧，如代码清单 $\text{8-7}$ 所示。 -$$ -P(i) = \frac{p_i^\alpha}{\sum_k p_k^\alpha} -$$ - -其中，$p_i$ 是样本 $i$ 的优先级，$\alpha$ 是一个超参数，用于调节优先采样的程序，通常在 $(0,1)$ 的区间内。当 $\alpha=0$ 时，采样概率为均匀分布；当 $\alpha =1$ 时，采样概率为优先级的线性分布。同时，即使对于最低优先级的样本，我们也不希望它们的采样概率为 $0$ ，因此我们可以在优先级上加上一个常数 $\epsilon$，即： - -$$ -p_i = |\delta_i| + \epsilon -$$ - -其中，$|\delta_i|$ 是样本 $i$ 的 TD 误差。当然，我们也可以使用其他的优先级计算方式，如： - -$$ -p_i = \frac{1}{rank(i)} -$$ - -其中，$rank(i)$ 是样本 $i$ 的优先级排名，这种方式也能保证每个样本的采样概率都不为 0，但在实践中，我们更倾向于直接增加一个常数 $\epsilon$ 的方式。 - -**重要性采样**。除了随机优先级采样之外，我们还引入了另外一个技巧，在讲解该技巧之前，我们需要简单了解一下重要性采样。重要性采样（Importance Sampling）是一种用于估计某一分布性质的方法，它的基本思想是，我们可以通过与待估计分布不同的另一个分布中采样，然后通过采样样本的权重来估计待估计分布的性质，数学表达式如下： - -$$ -\begin{aligned} -\mathbb{E}_{x \sim p(x)}[f(x)] &= \int f(x) p(x) dx \\ -&= \int f(x) \frac{p(x)}{q(x)} q(x) dx \\ -&= \int f(x) \frac{p(x)}{q(x)} \frac{q(x)}{p(x)} p(x) dx \\ -&= \mathbb{E}_{x \sim q(x)}\left[\frac{p(x)}{q(x)} f(x)\right] -\end{aligned} -$$ - -其中，$p(x)$ 是待估计分布，$q(x)$ 是采样分布，$f(x)$ 是待估计分布的性质。在前面我们讲到，每次计算的 TD 误差是对应之前的网络，而不是当前待更新的网络。也就是说，我们已经从之前的网络中采样了一批样本，也就是 $q(x)$ 已知，然后只要找到之前网络分布与当前网络分布之前的权重 $\frac{p(x)}{q(x)}$，就可以利用重要性采样来估计出当前网络的性质。我们可以定义权重为： - -$$ -w_i = \left(\frac{1}{N} \frac{1}{P(i)}\right)^\beta -$$ - -其中，$N$ 是经验回放中的样本数量，$P(i)$ 是样本 $i$ 的采样概率。同时，为了避免出现权重过大或过小的情况，我们可以对权重进行归一化处理： - -$$ -w_i = \frac{\left(N*P(i)\right)^{-\beta}}{\max_j (w_j)} -$$ - -**热偏置**。注意到，我们引入了一个超参数 $\beta$，用于调节重要性采样的程度。当 $\beta = 0$ 时，重要性采样的权重为 1，即不考虑重要性采样；当 $\beta = 1$ 时，重要性采样的权重为 $w_i$，即完全考虑重要性采样。在实践中，我们希望 $\beta$ 从 0 开始，随着训练步数的增加而逐渐增加，以便更好地利用重要性采样，这就是热偏置（Annealing The Bias）的思想。数学表达式如下： - -$$ -\beta = \min(1, \beta + \beta_{\text{step}}) -$$ - -其中，$\beta_{\text{step}}$ 是每个训练步数对应的 $\beta$ 的增量。在实践中，我们可以将 $\beta_{\text{step}}$ 设置为一个很小的常数，如 $0.0001$。这样一来，我们就可以在训练刚开始时，使用随机优先级采样，以便更快地收敛；在训练后期，使用重要性采样，以便更好地利用经验回放中的样本。 - -结合上面的优先级采样和重要性采样，我们可以基于 SumTree 实现一个带有优先级的经验回放，代码如下： +
+
代码清单 $\text{8-7}$ 优先级经验回放结构
+
```python class PrioritizedReplayBuffer: @@ -380,7 +531,11 @@ class PrioritizedReplayBuffer: return self.tree.count ``` -我们可以看到，优先级经验回放的核心是 SumTree，它可以在 $O(\log N)$ 的时间复杂度内完成添加、更新和采样操作。在实践中，我们可以将经验回放的容量设置为 $10^6$，并将 $\alpha$ 设置为 $0.6$，$\epsilon$ 设置为 $0.01$，$\beta$ 设置为 $0.4$，$\beta_{\text{step}}$ 设置为 $0.0001$。 当然我们也可以利用 Python 队列的方式实现优先级经验回放，形式上会更加简洁，并且在采样的时候减少了 for 循环的操作，会更加高效，如下： +$\qquad$ 我们可以看到，优先级经验回放的核心是 SumTree，它可以在 $O(\log N)$ 的时间复杂度内完成添加、更新和采样操作。在实践中，我们可以将经验回放的容量设置为 $10^6$，并将 $\alpha$ 设置为 $0.6$，$\epsilon$ 设置为 $0.01$，$\beta$ 设置为 $0.4$，$\beta_{\text{step}}$ 设置为 $0.0001$。 当然我们也可以利用 Python 队列的方式实现优先级经验回放，形式上会更加简洁，并且在采样的时候减少了 for 循环的操作，会更加高效，如代码清单 $\text{8-8}$ 所示。 + +
+
代码清单 $\text{8-7}$ 基于队列实现优先级经验回放
+
```python class PrioritizedReplayBufferQue: @@ -415,100 +570,9 @@ class PrioritizedReplayBufferQue: def __len__(self): return self.count ``` -最后，我们可以将优先级经验回放和 DQN 结合起来，实现一个带有优先级的 DQN 算法，伪代码如下： - -
- -
-
图 8.4 SumTree 结构
- -## C51 算法 - -分布式 DQN 算法，即 Distributed DQN，有时也会看到它也叫 Categorical DQN 这个名字，但最常见的名字是 C51 算法⑤ 。该算法跟 PER 算法一样，是从不同的角度改进强化学习算法，而不单单指 DQN 算法，而是能适用于任何基于 Q-learning 的强化学习算法。该算法的核心思想是将传统 DQN 算法中的值函数 $Q(s,a)$ 换成了值分布 $Z(x,a)$，即将值函数的输出从一个数值变成了一个分布，这样就能更好地处理值函数估计不准确以及离散动作空间的问题。 - -> ⑤ 论文链接：https://arxiv.org/abs/1707.06887 - -在之前讲到的经典强化学习算法中我们优化的其实是值分布的均值，也就是 $Q$ 函数，但实际上由于状态转移的随机性、函数近似等原因，智能体与环境之间也存在着随机性，这也导致了最终累积的回报也会是一个随机变量，使用一个确定的均值会忽略整个分布所提供的信息。。因此，我们可以将值函数 $Q$ 看成是一个随机变量，它的期望值就是 $Q$ 函数，而它的方差就是 $Q$ 函数的不确定性，公式表示如下： - -$$ -Q^\pi(x, a):=\mathbb{E} Z^\pi(x, a)=\mathbb{E}\left[\sum_{t=0}^{\infty} \gamma^t R\left(x_t, a_t\right)\right] -$$ - -其中状态分布 $x_t \sim P\left(\cdot \mid x_{t-1}, a_{t-1}\right), a_t \sim \pi\left(\cdot \mid x_t\right), x_0=x, a_0=a \text {. }$ - -## Rainbow DQN 算法 - -## 实战：Double DQN 算法 - -$\qquad$ 由于本章都是基于 $\text{DQN}$ 改进的算法，整体训练方式跟 $\text{DQN}$ 是一样的，也就是说伪代码基本都是一致的，因此不再赘述，只讲算法的改进部分。而 $\text{Double DQN}$ 算法跟 $\text{DQN}$ 算法的区别在于目标值的计算方式，如代码清单 $\text{8-1}$ 所示。 - -
-
代码清单 $\text{8-1}$ $\text{Double DQN}$目标值的计算
-
- -```python -# 计算当前网络的Q值，即Q(s_t+1|a) -next_q_value_batch = self.policy_net(next_state_batch) -# 计算目标网络的Q值，即Q'(s_t+1|a) -next_target_value_batch = self.target_net(next_state_batch) -# 计算 Q'(s_t+1|a=argmax Q(s_t+1|a)) -next_target_q_value_batch = next_target_value_batch.gather(1, torch.max(next_q_value_batch, 1)[1].unsqueeze(1)) -``` - -$\qquad$ 最后与 $\text{DQN}$ 算法相同，可以得到 $\text{Double DQN}$ 算法在 $\text{CartPole}$ 环境下的训练结果，如图 $\text{8-5}$ 所示，完整的代码可以参考本书的代码仓库。 +最后，我们可以将优先级经验回放和 DQN 结合起来，实现一个带有优先级的 DQN 算法，并展示它在 $\text{CartPole}$ 环境下的训练结果，如图 $\text{8-8}$ 所示。
- +
-
图 $\text{8-5}$ $\text{CartPole}$ 环境 $\text{Double DQN}$ 算法训练曲线
- -$\qquad$ 与 $\text{DQN}$ 算法的训练曲线对比可以看出，在实践上 $\text{Double DQN}$ 算法的效果并不一定比 $\text{DQN}$ 算法好，比如在这个环境下其收敛速度反而更慢了，因此读者需要多多实践才能摸索并体会到这些算法适合的场景。 - -## 实战：Dueling DQN 算法 - -$\qquad$ $\text{Dueling DQN}$ 算法主要是改了网络结构，其他地方跟 $\text{DQN}$ 是一模一样的，如代码清单 $\text{8-2}$ 所示。 - -
-
代码清单 $\text{8-2}$ $\text{Dueling DQN}$ 网络结构
-
- -```python -class DuelingQNetwork(nn.Module): - def __init__(self, state_dim, action_dim,hidden_dim=128): - super(DuelingQNetwork, self).__init__() - # 隐藏层 - self.hidden_layer = nn.Sequential( - nn.Linear(state_dim, hidden_dim), - nn.ReLU() - ) - # 优势层 - self.advantage_layer = nn.Sequential( - nn.Linear(hidden_dim, hidden_dim), - nn.ReLU(), - nn.Linear(hidden_dim, action_dim) - ) - # 价值层 - self.value_layer = nn.Sequential( - nn.Linear(hidden_dim, hidden_dim), - nn.ReLU(), - nn.Linear(hidden_dim, 1) - ) - - def forward(self, state): - x = self.hidden_layer(state) - advantage = self.advantage_layer(x) - value = self.value_layer(x) - return value + advantage - advantage.mean() # Q(s,a) = V(s) + A(s,a) - mean(A(s,a)) -``` - -$\qquad$ 最后我们展示一下它在 $\text{CartPole}$ 环境下的训练结果，如图 $\text{8-6}$ 所示，完整的代码同样可以参考本书的代码仓库。 - -
- -
-
图 $\text{8-5}$ $\text{CartPole}$ 环境 $\text{Dueling DQN}$ 算法训练曲线
- -$\qquad$ 由于环境比较简单，暂时还看不出来 $\text{Dueling DQN}$ 算法的优势，但是在复杂的环境下，比如 $\text{Atari}$ 游戏中，$\text{Dueling DQN}$ 算法的效果就会比 $\text{DQN}$ 算法好很多，读者可以在 $\text{JoyRL}$ 仓库中找到更复杂环境下的训练结果便于更好地进行对比。 - - - +
图 $\text{8-8}$ $\text{CartPole}$ 环境 $\text{PER DQN}$ 算法训练曲线
\ No newline at end of file diff --git a/docs/figs/ch8/NoisyDQN_CartPole-v1_training_curve.png b/docs/figs/ch8/NoisyDQN_CartPole-v1_training_curve.png new file mode 100644 index 0000000..b0a61e8 Binary files /dev/null and b/docs/figs/ch8/NoisyDQN_CartPole-v1_training_curve.png differ diff --git a/docs/figs/ch8/PERDQN_CartPole-v1_training_curve.png b/docs/figs/ch8/PERDQN_CartPole-v1_training_curve.png new file mode 100644 index 0000000..27f596b Binary files /dev/null and b/docs/figs/ch8/PERDQN_CartPole-v1_training_curve.png differ diff --git a/docs/figs/ch8/per_dqn_pseu.png b/docs/figs/ch8/per_dqn_pseu.png index 216daf7..056cf91 100644 Binary files a/docs/figs/ch8/per_dqn_pseu.png and b/docs/figs/ch8/per_dqn_pseu.png differ diff --git a/notebooks/NoisyDQN.ipynb b/notebooks/NoisyDQN.ipynb new file mode 100644 index 0000000..69c32f5 --- /dev/null +++ b/notebooks/NoisyDQN.ipynb @@ -0,0 +1,582 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. 定义算法\n", + "\n", + "NoisyDQN 是在 DQN 的基础上进行改进，主要就是通过在训练网络的时候加上一些噪声参数，可以用较小的额外计算成本，在强化学习算法上获得更优的结果。\n", + "配置和 DQN 基本一致，只是在模型定义的时候，在模型中加入了一些噪声参数。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1、 定义模型\n", + "这里使用了一个三层的MLP，不同的是其中加入了一些噪声参数，就是每个权值weight和偏置bias中都有额外的参数mu和sigma，这里仅供参考。" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "class NoisyLinear(nn.Module):\n", + " def __init__(self, input_dim, output_dim, std_init=0.4):\n", + " super(NoisyLinear, self).__init__()\n", + " \n", + " self.input_dim = input_dim\n", + " self.output_dim = output_dim\n", + " self.std_init = std_init\n", + " \n", + " self.weight_mu = nn.Parameter(torch.FloatTensor(output_dim, input_dim))\n", + " self.weight_sigma = nn.Parameter(torch.FloatTensor(output_dim, input_dim))\n", + " self.register_buffer('weight_epsilon', torch.FloatTensor(output_dim, input_dim))\n", + " \n", + " self.bias_mu = nn.Parameter(torch.FloatTensor(output_dim))\n", + " self.bias_sigma = nn.Parameter(torch.FloatTensor(output_dim))\n", + " self.register_buffer('bias_epsilon', torch.FloatTensor(output_dim))\n", + " \n", + " self.reset_parameters()\n", + " self.reset_noise()\n", + " \n", + " def forward(self, x):\n", + " if self.training: \n", + " weight = self.weight_mu + self.weight_sigma.mul(torch.tensor(self.weight_epsilon))\n", + " bias = self.bias_mu + self.bias_sigma.mul(torch.tensor(self.bias_epsilon))\n", + " else:\n", + " weight = self.weight_mu\n", + " bias = self.bias_mu\n", + " \n", + " return F.linear(x, weight, bias)\n", + " \n", + " def reset_parameters(self):\n", + " mu_range = 1 / math.sqrt(self.weight_mu.size(1))\n", + " \n", + " self.weight_mu.data.uniform_(-mu_range, mu_range)\n", + " self.weight_sigma.data.fill_(self.std_init / math.sqrt(self.weight_sigma.size(1)))\n", + " \n", + " self.bias_mu.data.uniform_(-mu_range, mu_range)\n", + " self.bias_sigma.data.fill_(self.std_init / math.sqrt(self.bias_sigma.size(0)))\n", + " \n", + " def reset_noise(self):\n", + " epsilon_in = self._scale_noise(self.input_dim)\n", + " epsilon_out = self._scale_noise(self.output_dim)\n", + " \n", + " self.weight_epsilon.copy_(epsilon_out.ger(epsilon_in))\n", + " self.bias_epsilon.copy_(self._scale_noise(self.output_dim))\n", + " \n", + " def _scale_noise(self, size):\n", + " x = torch.randn(size)\n", + " x = x.sign().mul(x.abs().sqrt())\n", + " return x\n", + "\n", + "class NoisyMLP(nn.Module):\n", + " def __init__(self, input_dim,output_dim,hidden_dim=128):\n", + " super(NoisyMLP, self).__init__()\n", + " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", + " self.noisy_fc2 = NoisyLinear(hidden_dim, hidden_dim)\n", + " self.noisy_fc3 = NoisyLinear(hidden_dim, output_dim)\n", + " \n", + " def forward(self, x):\n", + " x = F.relu(self.fc1(x))\n", + " x = F.relu(self.noisy_fc2(x))\n", + " x = self.noisy_fc3(x)\n", + " return x\n", + "\n", + " def reset_noise(self):\n", + " self.noisy_fc2.reset_noise()\n", + " self.noisy_fc3.reset_noise()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2、定义经验回放\n", + "\n", + "这里的经验回放和DQN中保持一致，也是具有一定容量，只有存储到一定的transition网络才会更新。经验回放的时候一般包涵两个功能或方法，一个是push，即将一个transition样本按顺序放到经验回放中，如果满了就把最开始放进去的样本挤掉；另外一个是sample，就是随机采样出一个或者若干个（具体多少就是batch_size了）样本供DQN网络更新。" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "from collections import deque\n", + "import random\n", + "class ReplayBuffer(object):\n", + " def __init__(self, capacity: int) -> None:\n", + " self.capacity = capacity\n", + " self.buffer = deque(maxlen=self.capacity)\n", + " def push(self,transitions):\n", + " ''' 存储transition到经验回放中\n", + " '''\n", + " self.buffer.append(transitions)\n", + " def sample(self, batch_size: int, sequential: bool = False):\n", + " if batch_size > len(self.buffer): # 如果批量大小大于经验回放的容量，则取经验回放的容量\n", + " batch_size = len(self.buffer)\n", + " if sequential: # 顺序采样\n", + " rand = random.randint(0, len(self.buffer) - batch_size)\n", + " batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n", + " return zip(*batch)\n", + " else: # 随机采样\n", + " batch = random.sample(self.buffer, batch_size)\n", + " return zip(*batch)\n", + " def clear(self):\n", + " ''' 清空经验回放\n", + " '''\n", + " self.buffer.clear()\n", + " def __len__(self):\n", + " ''' 返回当前存储的量\n", + " '''\n", + " return len(self.buffer)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3、模型算法定义\n", + "\n", + "这里根据前面的噪声MLP搭建智能体agent，其中的动作采样和模型更新和DQN基本一致，这里不再赘述。" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.optim as optim\n", + "import math\n", + "import numpy as np\n", + "\n", + "class NoisyDQN:\n", + " def __init__(self, model, memory, cfg) -> None:\n", + " self.n_actions = cfg.n_actions \n", + " self.device = torch.device(cfg.device) \n", + " self.gamma = cfg.gamma \n", + " ## e-greedy策略相关参数\n", + " self.sample_count = 0 # 用于epsilon的衰减计数\n", + " self.epsilon = cfg.epsilon_start\n", + " self.epsilon_start = cfg.epsilon_start\n", + " self.epsilon_end = cfg.epsilon_end\n", + " self.epsilon_decay = cfg.epsilon_decay\n", + " self.batch_size = cfg.batch_size\n", + " self.target_update = cfg.target_update\n", + "\n", + " self.device = torch.device(cfg.device) \n", + "\n", + " self.policy_net = model.to(self.device)\n", + " self.target_net = model.to(self.device)\n", + " ## 复制参数到目标网络\n", + " for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n", + " target_param.data.copy_(param.data)\n", + " self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr)\n", + " self.memory = memory ## 经验回放\n", + " self.update_flag = False\n", + " \n", + " def sample_action(self, state):\n", + " ''' sample action with e-greedy policy \n", + " '''\n", + " self.sample_count += 1\n", + " # epsilon 指数衰减\n", + " self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n", + " math.exp(-1. * self.sample_count / self.epsilon_decay) \n", + " if random.random() > self.epsilon:\n", + " with torch.no_grad():\n", + " state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n", + " q_values = self.policy_net(state)\n", + " action = q_values.max(1)[1].item() # 根据Q值选择动作\n", + " else:\n", + " action = random.randrange(self.n_actions)\n", + " return action\n", + "\n", + " @torch.no_grad()\n", + " def predict_action(self, state):\n", + " state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n", + " q_value = self.policy_net(state)\n", + " action = q_value.max(1)[1].item()\n", + " return action\n", + " def update(self):\n", + " if len(self.memory) < self.batch_size: # 不满足一个批量时，不更新策略\n", + " return\n", + " else:\n", + " if not self.update_flag:\n", + " print(\"Begin to update!\")\n", + " self.update_flag = True\n", + " # beta = min(1.0, self.beta_start + self.sample_count * (1.0 - self.beta_start) / self.beta_frames)\n", + " state_batch, action_batch, reward_batch, next_state_batch, done_batch = self.memory.sample(\n", + " self.batch_size)\n", + " # state_batch, action_batch, reward_batch, next_state_batch, done_batch, weights_batch, indices = self.memory.sample(self.batch_size, beta) \n", + " state_batch = torch.tensor(np.array(state_batch), device=self.device, dtype=torch.float) \n", + " action_batch = torch.tensor(action_batch, device=self.device).unsqueeze(1)\n", + " reward_batch = torch.tensor(reward_batch, device=self.device, dtype=torch.float).unsqueeze(1)\n", + " next_state_batch = torch.tensor(np.array(next_state_batch), device=self.device, dtype=torch.float) # shape(batchsize,n_states)\n", + " done_batch = torch.tensor(done_batch, device=self.device, dtype=torch.float).unsqueeze(1)\n", + " # weights_batch = torch.tensor(weights_batch, device=self.device, dtype=torch.float)\n", + "\n", + " q_value_batch = self.policy_net(state_batch).gather(dim=1, index=action_batch) # shape(batchsize,1),requires_grad=True\n", + " next_max_q_value_batch = self.target_net(next_state_batch).max(1)[0].detach().unsqueeze(1) \n", + " expected_q_value_batch = reward_batch + self.gamma * next_max_q_value_batch* (1-done_batch)\n", + "\n", + " loss = nn.MSELoss()(q_value_batch, expected_q_value_batch) # shape same to \n", + " # 反向传播\n", + " self.optimizer.zero_grad() \n", + " loss.backward()\n", + " # 梯度截断，防止梯度爆炸\n", + " for param in self.policy_net.parameters(): \n", + " param.grad.data.clamp_(-1, 1)\n", + " self.optimizer.step() \n", + "\n", + " if self.sample_count % self.target_update == 0: # 更新 target_net\n", + " self.target_net.load_state_dict(self.policy_net.state_dict()) \n", + "\n", + " ## 噪声参数重置\n", + " self.policy_net.reset_noise()\n", + " self.target_net.reset_noise()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2、 定义训练" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "def train(cfg, env, agent):\n", + " ''' 训练\n", + " '''\n", + " print(\"开始训练！\")\n", + " rewards = [] # 记录所有回合的奖励\n", + " steps = []\n", + " for i_ep in range(cfg.train_eps):\n", + " ep_reward = 0 # 记录一回合内的奖励\n", + " ep_step = 0\n", + " state = env.reset() # 重置环境，返回初始状态\n", + " for _ in range(cfg.max_steps):\n", + " ep_step += 1\n", + " action = agent.sample_action(state) # 选择动作\n", + " next_state, reward, done, _ = env.step(action) # 更新环境，返回transition\n", + " agent.memory.push((state, action, reward,next_state, done)) # 保存transition\n", + " state = next_state # 更新下一个状态\n", + " agent.update() # 更新智能体\n", + " ep_reward += reward # 累加奖励\n", + " if done:\n", + " break\n", + " if (i_ep + 1) % cfg.target_update == 0: # 智能体目标网络更新\n", + " agent.target_net.load_state_dict(agent.policy_net.state_dict())\n", + " steps.append(ep_step)\n", + " rewards.append(ep_reward)\n", + " if (i_ep + 1) % 10 == 0:\n", + " print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}，Epislon：{agent.epsilon:.3f}\")\n", + " print(\"完成训练！\")\n", + " env.close()\n", + " return {'rewards':rewards}\n", + "\n", + "def test(cfg, env, agent):\n", + " print(\"开始测试！\")\n", + " rewards = [] # 记录所有回合的奖励\n", + " steps = []\n", + " for i_ep in range(cfg.test_eps):\n", + " ep_reward = 0 # 记录一回合内的奖励\n", + " ep_step = 0\n", + " state = env.reset() # 重置环境，返回初始状态\n", + " for _ in range(cfg.max_steps):\n", + " ep_step+=1\n", + " action = agent.predict_action(state) # 选择动作\n", + " next_state, reward, done, _ = env.step(action) # 更新环境，返回transition\n", + " state = next_state # 更新下一个状态\n", + " ep_reward += reward # 累加奖励\n", + " if done:\n", + " break\n", + " steps.append(ep_step)\n", + " rewards.append(ep_reward)\n", + " print(f\"回合：{i_ep+1}/{cfg.test_eps}，奖励：{ep_reward:.2f}\")\n", + " print(\"完成测试\")\n", + " env.close()\n", + " return {'rewards':rewards}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. 定义环境" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [], + "source": [ + "import gym\n", + "import os\n", + "def all_seed(env,seed = 1):\n", + " ''' 万能的seed函数\n", + " '''\n", + " env.seed(seed) # env config\n", + " np.random.seed(seed)\n", + " random.seed(seed)\n", + " torch.manual_seed(seed) # config for CPU\n", + " torch.cuda.manual_seed(seed) # config for GPU\n", + " os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n", + " # config for cudnn\n", + " torch.backends.cudnn.deterministic = True\n", + " torch.backends.cudnn.benchmark = False\n", + " torch.backends.cudnn.enabled = False\n", + "def env_agent_config(cfg):\n", + " env = gym.make(cfg.env_name) # 创建环境\n", + " if cfg.seed !=0:\n", + " all_seed(env,seed=cfg.seed)\n", + " n_states = env.observation_space.shape[0]\n", + " n_actions = env.action_space.n\n", + " print(f\"状态空间维度：{n_states}，动作空间维度：{n_actions}\")\n", + "\n", + " cfg.n_actions = env.action_space.n ## set the env action space\n", + " model = NoisyMLP(n_states, n_actions, hidden_dim = cfg.hidden_dim) # 创建模型\n", + " memory = ReplayBuffer(cfg.buffer_size)\n", + " agent = NoisyDQN(model,memory,cfg)\n", + " return env,agent" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4、设置参数" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "import argparse\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "class Config():\n", + " def __init__(self) -> None:\n", + " self.env_name = \"CartPole-v1\" # 环境名字\n", + " self.new_step_api = True # 是否用gym的新api\n", + " self.wrapper = None \n", + " self.render = False \n", + " self.algo_name = \"NoisyDQN\" # 算法名字\n", + " self.mode = \"train\" # train or test\n", + " self.seed = 0 # 随机种子\n", + " self.device = \"cpu\" # device to use\n", + " self.train_eps = 100 # 训练的回合数\n", + " self.test_eps = 20 # 测试的回合数\n", + " self.eval_eps = 10 # 评估的回合数\n", + " self.eval_per_episode = 5 # 每个回合的评估次数\n", + " self.max_steps = 200 # 每个回合的最大步数\n", + " self.load_checkpoint = False\n", + " self.load_path = \"tasks\" # 加载模型的路径\n", + " self.show_fig = False # 是否展示图片\n", + " self.save_fig = True # 是否存储图片\n", + "\n", + "\n", + " # 设置epsilon值\n", + " self.epsilon_start = 0.95 # 起始的epsilon值\n", + " self.epsilon_end = 0.01 # 终止的epsilon值\n", + " self.epsilon_decay = 500 # 衰减率\n", + " self.hidden_dim = 256 \n", + " self.gamma = 0.95 \n", + " self.lr = 0.0001 \n", + " self.buffer_size = 100000 # 经验回放的buffer大小\n", + " self.batch_size = 64 # batch size\n", + " self.target_update = 4 # 目标网络更新频率\n", + " self.value_layers = [\n", + " {'layer_type': 'linear', 'layer_dim': ['n_states', 256],\n", + " 'activation': 'relu'},\n", + " {'layer_type': 'linear', 'layer_dim': [256, 256],\n", + " 'activation': 'relu'},\n", + " {'layer_type': 'linear', 'layer_dim': [256, 'n_actions'],\n", + " 'activation': 'none'}]\n", + "\n", + "def smooth(data, weight=0.9): \n", + " '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n", + " '''\n", + " last = data[0] \n", + " smoothed = []\n", + " for point in data:\n", + " smoothed_val = last * weight + (1 - weight) * point # 计算平滑值\n", + " smoothed.append(smoothed_val) \n", + " last = smoothed_val \n", + " return smoothed\n", + "\n", + "def plot_rewards(rewards,cfg, tag='train'):\n", + " ''' 画图\n", + " '''\n", + " sns.set()\n", + " plt.figure() # 创建一个图形实例，方便同时多画几个图\n", + " plt.title(f\"{tag}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\")\n", + " plt.xlabel('epsiodes')\n", + " plt.plot(rewards, label='rewards')\n", + " plt.plot(smooth(rewards), label='smoothed')\n", + " plt.legend()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5、开始训练" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "状态空间维度：4，动作空间维度：2\n", + "开始训练！\n", + "Begin to update!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/dingli/anaconda3/envs/joyrl/lib/python3.7/site-packages/ipykernel_launcher.py:26: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + "/home/dingli/anaconda3/envs/joyrl/lib/python3.7/site-packages/ipykernel_launcher.py:27: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "回合：10/100，奖励：11.00，Epislon：0.711\n", + "回合：20/100，奖励：18.00，Epislon：0.498\n", + "回合：30/100，奖励：20.00，Epislon：0.359\n", + "回合：40/100，奖励：20.00，Epislon：0.214\n", + "回合：50/100，奖励：94.00，Epislon：0.049\n", + "回合：60/100，奖励：200.00，Epislon：0.011\n", + "回合：70/100，奖励：200.00，Epislon：0.010\n", + "回合：80/100，奖励：200.00，Epislon：0.010\n", + "回合：90/100，奖励：200.00，Epislon：0.010\n", + "回合：100/100，奖励：200.00，Epislon：0.010\n", + "完成训练！\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "开始测试！\n", + "回合：1/20，奖励：200.00\n", + "回合：2/20，奖励：200.00\n", + "回合：3/20，奖励：200.00\n", + "回合：4/20，奖励：200.00\n", + "回合：5/20，奖励：200.00\n", + "回合：6/20，奖励：200.00\n", + "回合：7/20，奖励：200.00\n", + "回合：8/20，奖励：200.00\n", + "回合：9/20，奖励：200.00\n", + "回合：10/20，奖励：200.00\n", + "回合：11/20，奖励：200.00\n", + "回合：12/20，奖励：200.00\n", + "回合：13/20，奖励：200.00\n", + "回合：14/20，奖励：200.00\n", + "回合：15/20，奖励：200.00\n", + "回合：16/20，奖励：200.00\n", + "回合：17/20，奖励：200.00\n", + "回合：18/20，奖励：200.00\n", + "回合：19/20，奖励：200.00\n", + "回合：20/20，奖励：200.00\n", + "完成测试\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 获取参数\n", + "cfg = Config() \n", + "# 训练\n", + "env, agent = env_agent_config(cfg)\n", + "res_dic = train(cfg, env, agent)\n", + " \n", + "plot_rewards(res_dic['rewards'], cfg, tag=\"train\") \n", + "# 测试\n", + "res_dic = test(cfg, env, agent)\n", + "plot_rewards(res_dic['rewards'], cfg, tag=\"test\") # 画出结果" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.7.13 ('joyrl')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "996e2c1bcfa8ebbd3aba48733c28d7658f0aec7cda7e9a0e5abbef50d3f90575" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/PER_DQN.ipynb b/notebooks/PER_DQN.ipynb new file mode 100644 index 0000000..23ccb29 --- /dev/null +++ b/notebooks/PER_DQN.ipynb @@ -0,0 +1,644 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. 定义算法\n", + "\n", + "DQN 经验回放的算法中的均匀采样算法，可能会忘记一些重要的、以后使用的经验数据。针对这样的问题，PER_DQN 提出了优先级经验回放（prioritized experience reolay）的技术来解决，这种方法应用到 DQN 获得了更好的效果。PER_DQN 成功的原因有：1. 提出了sum tree这样复杂度为O(logn)的高效数据结构。 2. 正确估计了 weighted importance sampling. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1、 定义模型\n", + "\n", + "这里的 PER_DQN 的模型和 DQN 中类似，也是用的三层的MLP。" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "class MLP(nn.Module):\n", + " def __init__(self, n_states,n_actions,hidden_dim=128):\n", + " \"\"\" 初始化q网络，为全连接网络\n", + " \"\"\"\n", + " super(MLP, self).__init__()\n", + " self.fc1 = nn.Linear(n_states, hidden_dim) # 输入层\n", + " self.fc2 = nn.Linear(hidden_dim,hidden_dim) # 隐藏层\n", + " self.fc3 = nn.Linear(hidden_dim, n_actions) # 输出层\n", + " \n", + " def forward(self, x):\n", + " # 各层对应的激活函数\n", + " x = F.relu(self.fc1(x)) \n", + " x = F.relu(self.fc2(x))\n", + " return self.fc3(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2、定义经验回放\n", + "\n", + "这里的经验回放是和DQN中最大的不同。它使用了sum tree的数据结构，它是一种特殊的二叉树，其父亲节点的值等于子节点的和。节点上的值，定义为每个样本的优先度，这里就用TDerror来衡量。叶子上的数值就是样本优先度。\n", + "\n", + "sum tree 采样过程：根据根节点的priority和采样样本数，划分采样的区间，然后在这些区间中均应采样得到所要选取的样本的优先度。从根节点开始，逐层将样本的优先度和节点的优先度进行对比，最终可以得到所要采样的叶子样本。" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import random\n", + "\n", + "class SumTree:\n", + " '''SumTree for the per(Prioritized Experience Replay) DQN. \n", + " This SumTree code is a modified version and the original code is from:\n", + " https://github.com/MorvanZhou/Reinforcement-learning-with-tensorflow/blob/master/contents/5.2_Prioritized_Replay_DQN/RL_brain.py\n", + " '''\n", + " def __init__(self, capacity: int):\n", + " self.capacity = capacity\n", + " self.data_pointer = 0\n", + " self.n_entries = 0\n", + " self.tree = np.zeros(2 * capacity - 1)\n", + " self.data = np.zeros(capacity, dtype = object)\n", + "\n", + " def update(self, tree_idx, p):\n", + " '''Update the sampling weight\n", + " '''\n", + " change = p - self.tree[tree_idx]\n", + " self.tree[tree_idx] = p\n", + "\n", + " while tree_idx != 0:\n", + " tree_idx = (tree_idx - 1) // 2\n", + " self.tree[tree_idx] += change\n", + "\n", + " def add(self, p, data):\n", + " '''Adding new data to the sumTree\n", + " '''\n", + " tree_idx = self.data_pointer + self.capacity - 1\n", + " self.data[self.data_pointer] = data\n", + " # print (\"tree_idx=\", tree_idx)\n", + " # print (\"nonzero = \", np.count_nonzero(self.tree))\n", + " self.update(tree_idx, p)\n", + "\n", + " self.data_pointer += 1\n", + " if self.data_pointer >= self.capacity:\n", + " self.data_pointer = 0\n", + "\n", + " if self.n_entries < self.capacity:\n", + " self.n_entries += 1\n", + "\n", + " def get_leaf(self, v):\n", + " '''Sampling the data\n", + " '''\n", + " parent_idx = 0\n", + " while True:\n", + " cl_idx = 2 * parent_idx + 1\n", + " cr_idx = cl_idx + 1\n", + " if cl_idx >= len(self.tree):\n", + " leaf_idx = parent_idx\n", + " break\n", + " else:\n", + " if v <= self.tree[cl_idx] :\n", + " parent_idx = cl_idx\n", + " else:\n", + " v -= self.tree[cl_idx]\n", + " parent_idx = cr_idx\n", + "\n", + " data_idx = leaf_idx - self.capacity + 1\n", + " return leaf_idx, self.tree[leaf_idx], self.data[data_idx]\n", + "\n", + " def total(self):\n", + " return int(self.tree[0])\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "class ReplayTree:\n", + " '''ReplayTree for the per(Prioritized Experience Replay) DQN. \n", + " '''\n", + " def __init__(self, capacity):\n", + " self.capacity = capacity # the capacity for memory replay\n", + " self.tree = SumTree(capacity)\n", + " self.abs_err_upper = 1.\n", + "\n", + " ## hyper parameter for calculating the importance sampling weight\n", + " self.beta_increment_per_sampling = 0.001\n", + " self.alpha = 0.6\n", + " self.beta = 0.4\n", + " self.epsilon = 0.01 \n", + " self.abs_err_upper = 1.\n", + "\n", + " def __len__(self):\n", + " ''' return the num of storage\n", + " '''\n", + " return self.tree.total()\n", + "\n", + " def push(self, error, sample):\n", + " '''Push the sample into the replay according to the importance sampling weight\n", + " '''\n", + " p = (np.abs(error) + self.epsilon) ** self.alpha\n", + " self.tree.add(p, sample) \n", + "\n", + "\n", + " def sample(self, batch_size):\n", + " '''This is for sampling a batch data and the original code is from:\n", + " https://github.com/rlcode/per/blob/master/prioritized_memory.py\n", + " '''\n", + " pri_segment = self.tree.total() / batch_size\n", + "\n", + " priorities = []\n", + " batch = []\n", + " idxs = []\n", + "\n", + " is_weights = []\n", + "\n", + " self.beta = np.min([1., self.beta + self.beta_increment_per_sampling])\n", + " min_prob = np.min(self.tree.tree[-self.tree.capacity:]) / self.tree.total() \n", + "\n", + " for i in range(batch_size):\n", + " a = pri_segment * i\n", + " b = pri_segment * (i+1)\n", + "\n", + " s = random.uniform(a, b)\n", + " idx, p, data = self.tree.get_leaf(s)\n", + "\n", + " priorities.append(p)\n", + " batch.append(data)\n", + " idxs.append(idx)\n", + " prob = p / self.tree.total()\n", + "\n", + " sampling_probabilities = np.array(priorities) / self.tree.total()\n", + " is_weights = np.power(self.tree.n_entries * sampling_probabilities, -self.beta)\n", + " is_weights /= is_weights.max()\n", + "\n", + " return zip(*batch), idxs, is_weights\n", + " \n", + " def batch_update(self, tree_idx, abs_errors):\n", + " '''Update the importance sampling weight\n", + " '''\n", + " abs_errors += self.epsilon\n", + "\n", + " clipped_errors = np.minimum(abs_errors, self.abs_err_upper)\n", + " ps = np.power(clipped_errors, self.alpha)\n", + "\n", + " for ti, p in zip(tree_idx, ps):\n", + " self.tree.update(ti, p)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3、模型算法定义\n", + "\n", + "这里使用三层MLP搭建智能体agent，其中和DQN基本一致，这里不再赘述。" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.optim as optim\n", + "import math\n", + "import numpy as np\n", + "\n", + "\n", + "class PER_DQN:\n", + " def __init__(self, model, memory, cfg):\n", + "\n", + " self.n_actions = cfg.n_actions \n", + " self.device = torch.device(cfg.device) \n", + " self.gamma = cfg.gamma \n", + " ## e-greedy策略相关参数\n", + " self.sample_count = 0 # 用于epsilon的衰减计数\n", + " self.epsilon = cfg.epsilon_start\n", + " self.epsilon_start = cfg.epsilon_start\n", + " self.epsilon_end = cfg.epsilon_end\n", + " self.epsilon_decay = cfg.epsilon_decay\n", + " self.batch_size = cfg.batch_size\n", + " self.target_update = cfg.target_update\n", + "\n", + " self.policy_net = model.to(self.device)\n", + " self.target_net = model.to(self.device)\n", + " ## 复制参数到目标网络\n", + " for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n", + " target_param.data.copy_(param.data)\n", + " self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr) \n", + " self.memory = memory # SumTree 经验回放\n", + " self.update_flag = False \n", + " \n", + " def sample_action(self, state):\n", + " ''' sample action with e-greedy policy\n", + " '''\n", + " self.sample_count += 1\n", + " # epsilon 指数衰减\n", + " self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n", + " math.exp(-1. * self.sample_count / self.epsilon_decay) \n", + " if random.random() > self.epsilon:\n", + " with torch.no_grad():\n", + " state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n", + " q_values = self.policy_net(state)\n", + " action = q_values.max(1)[1].item() # 根据Q值选择动作\n", + " else:\n", + " action = random.randrange(self.n_actions)\n", + " return action\n", + "\n", + " def predict_action(self,state):\n", + " ''' 预测动作\n", + " '''\n", + " with torch.no_grad():\n", + " state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n", + " q_values = self.policy_net(state)\n", + " action = q_values.max(1)[1].item() \n", + " return action\n", + " def update(self):\n", + " if len(self.memory) < self.batch_size: # 不满足一个批量时，不更新策略\n", + " return\n", + " else:\n", + " if not self.update_flag:\n", + " print(\"Begin to update!\")\n", + " self.update_flag = True\n", + " # 采样一个batch\n", + " (state_batch, action_batch, reward_batch, next_state_batch, done_batch), idxs_batch, is_weights_batch = self.memory.sample(\n", + " self.batch_size)\n", + " state_batch = torch.tensor(np.array(state_batch), device=self.device, dtype=torch.float) # shape(batchsize,n_states)\n", + " action_batch = torch.tensor(action_batch, device=self.device).unsqueeze(1) # shape(batchsize,1)\n", + " reward_batch = torch.tensor(reward_batch, device=self.device, dtype=torch.float).unsqueeze(1) # shape(batchsize,1)\n", + " next_state_batch = torch.tensor(np.array(next_state_batch), device=self.device, dtype=torch.float) # shape(batchsize,n_states)\n", + " done_batch = torch.tensor(np.float32(done_batch), device=self.device).unsqueeze(1) # shape(batchsize,1)\n", + " q_value_batch = self.policy_net(state_batch).gather(dim=1, index=action_batch) # shape(batchsize,1),requires_grad=True\n", + " next_max_q_value_batch = self.target_net(next_state_batch).max(1)[0].detach().unsqueeze(1) \n", + " expected_q_value_batch = reward_batch + self.gamma * next_max_q_value_batch* (1-done_batch)\n", + "\n", + " # loss中根据优先度进行了加权\n", + " loss = torch.mean(torch.pow((q_value_batch - expected_q_value_batch) * torch.from_numpy(is_weights_batch).to(self.device), 2))\n", + "\n", + " # loss = nn.MSELoss()(q_value_batch, expected_q_value_batch) \n", + "\n", + " abs_errors = np.sum(np.abs(q_value_batch.cpu().detach().numpy() - expected_q_value_batch.cpu().detach().numpy()), axis=1)\n", + " # 需要更新样本的优先度\n", + " self.memory.batch_update(idxs_batch, abs_errors) \n", + "\n", + " # 反向传播\n", + " self.optimizer.zero_grad() \n", + " loss.backward()\n", + " # 梯度截断，防止梯度爆炸\n", + " for param in self.policy_net.parameters(): \n", + " param.grad.data.clamp_(-1, 1)\n", + " self.optimizer.step() \n", + " if self.sample_count % self.target_update == 0: # 更新 target_net\n", + " self.target_net.load_state_dict(self.policy_net.state_dict()) \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2、 定义训练" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "def train(cfg, env, agent):\n", + " ''' 训练\n", + " '''\n", + " print(\"开始训练！\")\n", + " rewards = [] # 记录所有回合的奖励\n", + " steps = []\n", + " for i_ep in range(cfg.train_eps):\n", + " ep_reward = 0 # 记录一回合内的奖励\n", + " ep_step = 0\n", + " state = env.reset() # 重置环境，返回初始状态\n", + " for _ in range(cfg.max_steps):\n", + " ep_step += 1\n", + " action = agent.sample_action(state) # 选择动作\n", + " next_state, reward, done, _= env.step(action) # 更新环境，返回transition\n", + "\n", + " ## PER DQN 特有的内容\n", + " policy_val = agent.policy_net(torch.tensor(state, device = cfg.device))[action]\n", + " target_val = agent.target_net(torch.tensor(next_state, device = cfg.device))\n", + "\n", + " if done:\n", + " error = abs(policy_val - reward)\n", + " else:\n", + " error = abs(policy_val - reward - cfg.gamma * torch.max(target_val))\n", + "\n", + " agent.memory.push(error.cpu().detach().numpy(), (state, action, reward,\n", + " next_state, done)) # 保存transition\n", + " \n", + " agent.update() # 更新智能体\n", + " state = next_state # 更新下一个状态\n", + " ep_reward += reward # 累加奖励\n", + " if done:\n", + " break\n", + " if (i_ep + 1) % cfg.target_update == 0: # 智能体目标网络更新\n", + " agent.target_net.load_state_dict(agent.policy_net.state_dict())\n", + " steps.append(ep_step)\n", + " rewards.append(ep_reward)\n", + " if (i_ep + 1) % 10 == 0:\n", + " print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}，Epislon：{agent.epsilon:.3f}\")\n", + " print(\"完成训练！\")\n", + " env.close()\n", + " return {'rewards':rewards}\n", + "\n", + "def test(cfg, env, agent):\n", + " print(\"开始测试！\")\n", + " rewards = [] # 记录所有回合的奖励\n", + " steps = []\n", + " for i_ep in range(cfg.test_eps):\n", + " ep_reward = 0 # 记录一回合内的奖励\n", + " ep_step = 0\n", + " state = env.reset() # 重置环境，返回初始状态\n", + " for _ in range(cfg.max_steps):\n", + " ep_step+=1\n", + " action = agent.predict_action(state) # 选择动作\n", + " next_state, reward, done, _ = env.step(action) # 更新环境，返回transition\n", + " state = next_state # 更新下一个状态\n", + " ep_reward += reward # 累加奖励\n", + " if done:\n", + " break\n", + " steps.append(ep_step)\n", + " rewards.append(ep_reward)\n", + " print(f\"回合：{i_ep+1}/{cfg.test_eps}，奖励：{ep_reward:.2f}\")\n", + " print(\"完成测试\")\n", + " env.close()\n", + " return {'rewards':rewards}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. 定义环境" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "import gym\n", + "import os\n", + "def all_seed(env,seed = 1):\n", + " ''' 万能的seed函数\n", + " '''\n", + " env.seed(seed) # env config\n", + " np.random.seed(seed)\n", + " random.seed(seed)\n", + " torch.manual_seed(seed) # config for CPU\n", + " torch.cuda.manual_seed(seed) # config for GPU\n", + " os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n", + " # config for cudnn\n", + " torch.backends.cudnn.deterministic = True\n", + " torch.backends.cudnn.benchmark = False\n", + " torch.backends.cudnn.enabled = False\n", + "def env_agent_config(cfg):\n", + " env = gym.make(cfg.env_name) # 创建环境\n", + " if cfg.seed !=0:\n", + " all_seed(env,seed=cfg.seed)\n", + " n_states = env.observation_space.shape[0]\n", + " n_actions = env.action_space.n\n", + " print(f\"状态空间维度：{n_states}，动作空间维度：{n_actions}\")\n", + "\n", + " cfg.n_actions = env.action_space.n ## set the env action space\n", + " model = MLP(n_states, n_actions, hidden_dim = cfg.hidden_dim) # 创建模型\n", + " memory = ReplayTree(cfg.buffer_size)\n", + " agent = PER_DQN(model,memory,cfg)\n", + " return env,agent" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4、设置参数" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "import argparse\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "class Config():\n", + " def __init__(self) -> None:\n", + " self.env_name = \"CartPole-v1\" # 环境名字\n", + " self.new_step_api = True # 是否用gym的新api\n", + " self.wrapper = None \n", + " self.render = False \n", + " self.algo_name = \"PER_DQN\" # 算法名字\n", + " self.mode = \"train\" # train or test\n", + " self.seed = 0 # 随机种子\n", + " self.device = \"cpu\" # device to use\n", + " self.train_eps = 100 # 训练的回合数\n", + " self.test_eps = 20 # 测试的回合数\n", + " self.eval_eps = 10 # 评估的回合数\n", + " self.eval_per_episode = 5 # 每个回合的评估次数\n", + " self.max_steps = 200 # 每个回合的最大步数\n", + " self.load_checkpoint = False\n", + " self.load_path = \"tasks\" # 加载模型的路径\n", + " self.show_fig = False # 是否展示图片\n", + " self.save_fig = True # 是否存储图片\n", + "\n", + " # 设置epsilon值\n", + " self.epsilon_start = 0.95 # 起始的epsilon值\n", + " self.epsilon_end = 0.01 # 终止的epsilon值\n", + " self.epsilon_decay = 500 # 衰减率\n", + " self.hidden_dim = 256 \n", + " self.gamma = 0.95 \n", + " self.lr = 0.0001 \n", + " self.buffer_size = 100000 # 经验回放的buffer大小\n", + " self.batch_size = 64 # batch size\n", + " self.target_update = 4 # 目标网络更新频率\n", + " self.value_layers = [\n", + " {'layer_type': 'linear', 'layer_dim': ['n_states', 256],\n", + " 'activation': 'relu'},\n", + " {'layer_type': 'linear', 'layer_dim': [256, 256],\n", + " 'activation': 'relu'},\n", + " {'layer_type': 'linear', 'layer_dim': [256, 'n_actions'],\n", + " 'activation': 'none'}]\n", + "\n", + "def smooth(data, weight=0.9): \n", + " '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n", + " '''\n", + " last = data[0] \n", + " smoothed = []\n", + " for point in data:\n", + " smoothed_val = last * weight + (1 - weight) * point # 计算平滑值\n", + " smoothed.append(smoothed_val) \n", + " last = smoothed_val \n", + " return smoothed\n", + "\n", + "def plot_rewards(rewards,cfg, tag='train'):\n", + " ''' 画图\n", + " '''\n", + " sns.set()\n", + " plt.figure() # 创建一个图形实例，方便同时多画几个图\n", + " plt.title(f\"{tag}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\")\n", + " plt.xlabel('epsiodes')\n", + " plt.plot(rewards, label='rewards')\n", + " plt.plot(smooth(rewards), label='smoothed')\n", + " plt.legend()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5、开始训练" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "状态空间维度：4，动作空间维度：2\n", + "开始训练！\n", + "Begin to update!\n", + "回合：10/100，奖励：10.00，Epislon：0.569\n", + "回合：20/100，奖励：12.00，Epislon：0.443\n", + "回合：30/100，奖励：10.00，Epislon：0.357\n", + "回合：40/100，奖励：15.00，Epislon：0.268\n", + "回合：50/100，奖励：125.00，Epislon：0.103\n", + "回合：60/100，奖励：67.00，Epislon：0.024\n", + "回合：70/100，奖励：200.00，Epislon：0.012\n", + "回合：80/100，奖励：200.00，Epislon：0.010\n", + "回合：90/100，奖励：200.00，Epislon：0.010\n", + "回合：100/100，奖励：200.00，Epislon：0.010\n", + "完成训练！\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "开始测试！\n", + "回合：1/20，奖励：200.00\n", + "回合：2/20，奖励：200.00\n", + "回合：3/20，奖励：200.00\n", + "回合：4/20，奖励：200.00\n", + "回合：5/20，奖励：200.00\n", + "回合：6/20，奖励：200.00\n", + "回合：7/20，奖励：200.00\n", + "回合：8/20，奖励：200.00\n", + "回合：9/20，奖励：200.00\n", + "回合：10/20，奖励：200.00\n", + "回合：11/20，奖励：200.00\n", + "回合：12/20，奖励：200.00\n", + "回合：13/20，奖励：200.00\n", + "回合：14/20，奖励：200.00\n", + "回合：15/20，奖励：200.00\n", + "回合：16/20，奖励：200.00\n", + "回合：17/20，奖励：200.00\n", + "回合：18/20，奖励：200.00\n", + "回合：19/20，奖励：200.00\n", + "回合：20/20，奖励：200.00\n", + "完成测试\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 获取参数\n", + "cfg = Config() \n", + "# 训练\n", + "env, agent = env_agent_config(cfg)\n", + "res_dic = train(cfg, env, agent)\n", + " \n", + "plot_rewards(res_dic['rewards'], cfg, tag=\"train\") \n", + "# 测试\n", + "res_dic = test(cfg, env, agent)\n", + "plot_rewards(res_dic['rewards'], cfg, tag=\"test\") # 画出结果" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.7.13 ('joyrl')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "996e2c1bcfa8ebbd3aba48733c28d7658f0aec7cda7e9a0e5abbef50d3f90575" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/pseudocodes/pseudo.tex b/pseudocodes/pseudo.tex index 7fee078..7d57138 100644 --- a/pseudocodes/pseudo.tex +++ b/pseudocodes/pseudo.tex @@ -260,7 +260,7 @@ \section{PER-DQN算法} \begin{algorithmic}[1] % \REQUIRE $n \geq 0 \vee x \neq 0$ % 输入 % \ENSURE $y = x^n$ % 输出 - \STATE 初始化策略网络参数$\theta$ % 初始化 + \STATE 初始化当前网络参数$\theta$ % 初始化 \STATE 复制参数到目标网络$\hat{Q} \leftarrow Q$ \STATE 初始化经验回放$D$ \FOR {回合数 = $1,M$} diff --git a/pseudocodes/pseudo_without_notes.pdf b/pseudocodes/pseudo_without_notes.pdf index 332311c..de2820c 100644 Binary files a/pseudocodes/pseudo_without_notes.pdf and b/pseudocodes/pseudo_without_notes.pdf differ diff --git a/pseudocodes/pseudo_without_notes.tex b/pseudocodes/pseudo_without_notes.tex index 78984cb..2b4fe48 100644 --- a/pseudocodes/pseudo_without_notes.tex +++ b/pseudocodes/pseudo_without_notes.tex @@ -248,39 +248,36 @@ \section{DRQN算法} \section{PER-DQN算法} \begin{algorithm}[H] % [H]固定位置 - \floatname{algorithm}{{PER-DQN算法}\footnotemark[1]} + \floatname{algorithm}{{PER-DQN算法}} \renewcommand{\thealgorithm}{} % 去掉算法标号 \caption{} \renewcommand{\algorithmicrequire}{\textbf{输入:}} \renewcommand{\algorithmicensure}{\textbf{输出:}} \begin{algorithmic}[1] - % \REQUIRE $n \geq 0 \vee x \neq 0$ % 输入 - % \ENSURE $y = x^n$ % 输出 - \STATE 初始化策略网络参数$\theta$ % 初始化 - \STATE 复制参数到目标网络$\hat{Q} \leftarrow Q$ + \STATE 初始化当前网络参数 $\theta$ + \STATE 复制参数到目标网络$\hat{\theta} \leftarrow \theta$ \STATE 初始化经验回放$D$ - \FOR {回合数 = $1,M$} - \STATE 重置环境，获得初始状态$s_t$ - \FOR {时步 = $1,t$} + \FOR {回合数 $m = 1,2,\cdots,M$} + \STATE 重置环境，获得初始状态$s_0$ + \FOR {时步 $t= 1,2,\cdots,T$} + \STATE {\bfseries 交互采样：} \STATE 根据$\varepsilon-greedy$策略采样动作$a_t$ \STATE 环境根据$a_t$反馈奖励$r_t$和下一个状态$s_{t+1}$ - \STATE 存储transition即$(s_t,a_t,r_t,s_{t+1})$到经验回放$D$，并根据TD-error损失确定其优先级$p_t$ + \STATE 存储样本$(s_t,a_t,r_t,s_{t+1})$到经验回放$D$中，并根据$TD$误差损失确定其优先级$p_t$ \STATE 更新环境状态$s_{t+1} \leftarrow s_t$ - \STATE {\bfseries 更新策略：} - \STATE 按照经验回放中的优先级别，每个样本采样概率为$P(j)=p_j^\alpha / \sum_i p_i^\alpha$，从$D$中采样一个大小为batch的transition + \STATE {\bfseries 模型更新：} + \STATE 根据每个样本的优先级计算采样概率$P(j)=p_j^\alpha / \sum_i p_i^\alpha$，从$D$中采样一个批量的样本 \STATE 计算各个样本重要性采样权重 $w_j=(N \cdot P(j))^{-\beta} / \max _i w_i$ - \STATE 计算TD-error $\delta_j$ ; 并根据TD-error更新优先级$p_j$ - \STATE 计算实际的$Q$值，即$y_{j}$\footnotemark[2] - \STATE 根据重要性采样权重调整损失 $L(\theta)=\left(y_{j}-Q\left(s_{j}, a_{j} ; \theta\right)\cdot w_j \right)^{2}$，并将其关于参数$\theta$做随机梯度下降\footnotemark[3] + \STATE 计算$TD$误差$\delta_j$ ; 并根据$TD$误差更新优先级$p_j$ + \STATE 计算$Q$的估计值，即$y_{j}$ + \STATE 根据重要性采样权重调整损失 $L(\theta)=\left(y_{j}-Q\left(s_{j}, a_{j} ; \theta\right)\cdot w_j \right)^{2}$，并关于$\theta$做随机梯度下降 + \STATE 每$C$步复制参数$\hat{Q}\leftarrow Q$ \ENDFOR - \STATE 每$C$个回合复制参数$\hat{Q}\leftarrow Q$\footnotemark[4] + \ENDFOR \end{algorithmic} \end{algorithm} -\footnotetext[1]{Playing Atari with Deep Reinforcement Learning} -\footnotetext[2]{$y_{i}= \begin{cases}r_{i} & \text {对于终止状态} s_{i+1} \\ r_{i}+\gamma \max _{a^{\prime}} Q\left(s_{i+1}, a^{\prime} ; \theta\right) & \text {对于非终止状态} s_{i+1}\end{cases}$} -\footnotetext[3]{$\theta_i \leftarrow \theta_i - \lambda \nabla_{\theta_{i}} L_{i}\left(\theta_{i}\right)$} -\footnotetext[4]{此处也可像原论文中放到小循环中改成每$C$步，但没有每$C$个回合稳定} + \clearpage diff --git a/pseudocodes/texput.log b/pseudocodes/texput.log new file mode 100644 index 0000000..66986a5 --- /dev/null +++ b/pseudocodes/texput.log @@ -0,0 +1,21 @@ +This is XeTeX, Version 3.141592653-2.6-0.999994 (TeX Live 2022) (preloaded format=xelatex 2022.8.16) 20 AUG 2023 16:24 +entering extended mode + restricted \write18 enabled. + %&-line parsing enabled. +** + +! Emergency stop. +<*> + +End of file on the terminal! + + +Here is how much of TeX's memory you used: + 4 strings out of 476179 + 35 string characters out of 5813072 + 298507 words of memory out of 5000000 + 20858 multiletter control sequences out of 15000+600000 + 469259 words of font info for 28 fonts, out of 8000000 for 9000 + 1348 hyphenation exceptions out of 8191 + 0i,0n,0p,28b,6s stack positions out of 10000i,1000n,20000p,200000b,200000s +No pages of output.