diff --git a/docs/ch12/main.md b/docs/ch12/main.md
index 2bfd917..c7a41e1 100644
--- a/docs/ch12/main.md
+++ b/docs/ch12/main.md
@@ -1,12 +1,14 @@
-# PPO 算法
+# 第 12 章 PPO 算法
-$\qquad$ 本章我们开始讲解强化学习中最最最泛用的 $\text{PPO}$ 算法（$\text{proximal policy optimization}$），这个算法在强化学习领域的研究和应用中有着非常重要的地位，可以说是强化学习领域的一个里程碑式的算法。$\text{PPO}$ 算法是一种基于策略梯度的强化学习算法，由 $\text{OpenAI}$ 的研究人员 $\text{Schulman}$ 等人在 $\text{2017}$ 年提出。$\text{PPO}$ 算法的主要思想是通过在策略梯度的优化过程中引入一个重要性比率来限制策略更新的幅度，从而提高算法的稳定性和收敛性。$\text{PPO}$ 算法的优点在于简单、易于实现、易于调参，而且在实际应用中的效果也非常好，因此在强化学习领域得到了广泛的应用。
+$\qquad$ 本章我们开始讲解强化学习中比较重要的 $\text{PPO}$ 算法，它在相关应用中有着非常重要的地位，是一个里程碑式的算法。不同于 $\text{DDPG}$ 算法，$\text{PPO}$ 算法是一类典型的 $\text{Actor-Critic}$ 算法，既适用于连续动作空间，也适用于离散动作空间。
+
+$\qquad$ $\text{PPO}$ 算法是一种基于策略梯度的强化学习算法，由 $\text{OpenAI}$ 的研究人员 $\text{Schulman}$ 等人在 $\text{2017}$ 年提出。$\text{PPO}$ 算法的主要思想是通过在策略梯度的优化过程中引入一个重要性权重来限制策略更新的幅度，从而提高算法的稳定性和收敛性。$\text{PPO}$ 算法的优点在于简单、易于实现、易于调参，应用十分广泛，正可谓 “遇事不决 $\text{PPO}$ ”。
$\qquad$ $\text{PPO}$ 的前身是 $\text{TRPO}$ 算法，旨在克服 $\text{TRPO}$ 算法中的一些计算上的困难和训练上的不稳定性。$\text{TRPO}$ 是一种基于策略梯度的算法，它通过定义策略更新的信赖域来保证每次更新的策略不会太远离当前的策略，以避免过大的更新引起性能下降。然而，$\text{TRPO}$ 算法需要解决一个复杂的约束优化问题，计算上较为繁琐。本书主要出于实践考虑，这种太复杂且几乎已经被淘汰的 $\text{TRPO}$ 算法就不再赘述了，需要深入研究或者工作面试的读者可以自行查阅相关资料。 接下来将详细讲解 $\text{PPO}$ 算法的原理和实现，希望能够帮助读者更好地理解和掌握这个算法。
-## 重要性采样
+## 12.1 重要性采样
-$\qquad$ 在将 $\text{PPO}$ 算法之前，我们需要铺垫一个概念，那就是重要性采样（ $\text{importance sampling}$ ）。重要性采样是一种估计随机变量的期望或者概率分布的统计方法。它的原理也很简单，假设有一个函数 $f(x)$ ，需要从分布 $p(x)$ 中采样来计算其期望值，但是在某些情况下我们可能很难从 $p(x)$ 中采样，这个时候我们可以从另一个比较容易采样的分布 $q(x)$ 中采样，来间接地达到从 $p(x)$ 中采样的效果。这个过程的数学表达式如式 $\text{(12.1)}$ 所示。
+$\qquad$ 在展开 $\text{PPO}$ 算法之前，我们先铺垫一个概念，即重要性采样（ $\text{importance sampling}$ ）。重要性采样是一种估计随机变量的期望或者概率分布的统计方法。它的原理也很简单，假设有一个函数 $f(x)$ ，需要从分布 $p(x)$ 中采样来计算其期望值，但是在某些情况下我们可能很难从 $p(x)$ 中采样，这个时候我们可以从另一个比较容易采样的分布 $q(x)$ 中采样，来间接地达到从 $p(x)$ 中采样的效果。这个过程的数学表达式如式 $\text{(12.1)}$ 所示。
$$
\tag{12.1}
@@ -17,7 +19,9 @@ $\qquad$ 对于离散分布的情况，可以表达为式 $\text{(12.2)}$ 。
$$
\tag{12.2}
+\begin{aligned}
E_{p(x)}[f(x)]=\frac{1}{N} \sum f\left(x_{i}\right) \frac{p\left(x_{i}\right)}{q\left(x_{i}\right)}
+\end{aligned}
$$
$\qquad$ 这样一来原问题就变成了只需要从 $q(x)$ 中采样，然后计算两个分布之间的比例 $\frac{p(x)}{q(x)}$ 即可，这个比例称之为**重要性权重**。换句话说，每次从 $q(x)$ 中采样的时候，都需要乘上对应的重要性权重来修正采样的偏差，即两个分布之间的差异。当然这里可能会有一个问题，就是当 $p(x)$ 不为 $\text{0}$ 的时候，$q(x)$ 也不能为 $\text{0}$，但是他们可以同时为 $\text{0}$ ，这样 $\frac{p(x)}{q(x)}$ 依然有定义，具体的原理由于并不是很重要，因此就不展开讲解了。
@@ -33,15 +37,17 @@ $\qquad$ 结合重要性采样公式，我们可以得到式 $\text{(12.4)}$ 。
$$
\tag{12.4}
+\begin{aligned}
Var_{x \sim q}\left[f(x) \frac{p(x)}{q(x)}\right]=E_{x \sim q}\left[\left(f(x) \frac{p(x)}{q(x)}\right)^{2}\right]-\left(E_{x \sim q}\left[f(x) \frac{p(x)}{q(x)}\right]\right)^{2} \\
-=E_{x \sim p}\left[f(x)^{2} \frac{p(x)}{q(x)}\right]-\left(E_{x \sim p}[f(x)]\right)^{2}
+= E_{x \sim p}\left[f(x)^{2} \frac{p(x)}{q(x)}\right]-\left(E_{x \sim p}[f(x)]\right)^{2}
+\end{aligned}
$$
$\qquad$ 不难看出，当 $q(x)$ 越接近 $p(x)$ 的时候，方差就越小，也就是说重要性权重越接近于 $1$ 的时候，反之越大。
$\qquad$ 其实重要性采样也是蒙特卡洛估计的一部分，只不过它是一种比较特殊的蒙特卡洛估计，允许我们在复杂问题中利用已知的简单分布进行采样，从而避免了直接采样困难分布的问题，同时通过适当的权重调整，可以使得蒙特卡洛估计更接近真实结果。
-## PPO 算法
+## 12.2 PPO 算法
$\qquad$ 既然重要性采样本质上是一种在某些情况下更优的蒙特卡洛估计，再结合前面 $\text{Actor-Critic}$ 章节中我们讲到策略梯度算法的高方差主要来源于 $\text{Actor}$ 的策略梯度采样估计，读者应该不难猜出 $\text{PPO}$ 算法具体是优化在什么地方了。没错，$\text{PPO}$ 算法的核心思想就是通过重要性采样来优化原来的策略梯度估计，其目标函数表示如式 $\text{(12.5)}$ 所示。
@@ -80,10 +86,79 @@ $$
J^{KL}(\theta)=\hat{\mathbb{E}}_t\left[\frac{\pi_\theta\left(a_t \mid s_t\right)}{\pi_{\theta_{\text {old }}}\left(a_t \mid s_t\right)} \hat{A}_t-\beta \mathrm{KL}\left[\pi_{\theta_{\text {old }}}\left(\cdot \mid s_t\right), \pi_\theta\left(\cdot \mid s_t\right)\right]\right]
$$
-$\text{KL}$ 约束一般也叫 $\text{KL-penalty}$，它的意思是在 $\text{TRPO}$ 损失的基础上，加上一个 $\text{KL}$ 散度的惩罚项，这个惩罚项的系数 $\beta$ 一般取 $0.01$ 左右。这个惩罚项的作用也是保证每次更新的策略分布都不会偏离上一次的策略分布太远，从而保证重要性权重不会偏离 $1$ 太远。在实践中，我们一般用 $\text{clip}$ 约束，因为它更简单，计算成本较低，而且效果也更好。
-
-## 一个常见的误区
-
-在很早的章节之前，我们讲过 `on-policy` 和
-
-## 实战：PPO 算法
\ No newline at end of file
+$\qquad$ $\text{KL}$ 约束一般也叫 $\text{KL-penalty}$，它的意思是在 $\text{TRPO}$ 损失的基础上，加上一个 $\text{KL}$ 散度的惩罚项，这个惩罚项的系数 $\beta$ 一般取 $0.01$ 左右。这个惩罚项的作用也是保证每次更新的策略分布都不会偏离上一次的策略分布太远，从而保证重要性权重不会偏离 $1$ 太远。在实践中，我们一般用 $\text{clip}$ 约束，因为它更简单，计算成本较低，而且效果也更好。
+
+## 12.3 一个常见的误区
+
+$\qquad$ 在之前的章节中，我们讲过 $\text{on-policy}$ 和 $\text{off-policy}$ 算法，前者使用当前策略生成样本，并基于这些样本来更新该策略，后者则可以使用过去的策略采集样本来更新当前的策略。$\text{on-policy}$ 算法的数据利用效率较低，因为每次策略更新后，旧的样本或经验可能就不再适用，通常需要重新采样。而 $\text{off-policy}$ 算法由于可以利用历史经验，一般使用经验回放来存储和重复利用之前的经验，数据利用效率则较高，因为同一批数据可以被用于多次更新。但由于经验的再利用，可能会引入一定的偏见，但这也有助于稳定学习。但在需要即时学习和适应的环境中，$\text{on-policy}$ 算法可能更为适合，因为它们直接在当前策略下操作。
+
+$\qquad$ 那么 $\text{PPO}$ 算法究竟是 $\text{on-policy}$ 还是 $\text{off-policy}$ 的呢？有读者可能会因为 $\text{PPO}$ 算法在更新时重要性采样的部分中利用了旧的 $\text{Actor}$ 采样的样本，就觉得 $\text{PPO}$ 算法会是 $\text{off-policy}$ 的。实际上虽然这批样本是从旧的策略中采样得到的，但我们并没有直接使用这些样本去更新我们的策略，而是使用重要性采样先将数据分布不同导致的误差进行了修正，即是两者样本分布之间的差异尽可能地缩小。换句话说，就可以理解为重要性采样之后的样本虽然是由旧策略采样得到的，但可以近似为从更新后的策略中得到的，即我们要优化的 $\text{Actor}$ 和采样的 $\text{Actor}$ 是同一个，因此 **$\text{PPO}$ 算法是 $\text{on-policy}$ 的**。
+
+## 12.4 实战：PPO 算法
+### 12.4.1 PPO 伪代码
+
+$\qquad$ 如图 $\text{12-1}$ 所示，与 $\text{off-policy}$ 算法不同，$\text{PPO}$ 算法每次会采样若干个时步的样本，然后利用这些样本更新策略，而不是存入经验回放中进行采样更新。
+
+
+
+
图 $\text{12-1}$ $\text{PPO}$ 算法伪代码
+
+### 12.4.2 PPO 算法更新
+
+$\qquad$ 无论是连续动作空间还是离散动作空间，$\text{PPO}$ 算法的动作采样方式跟前面章节讲的 $\text{Actor-Critic}$ 算法是一样的，在本次实战中就不做展开，读者可在 $\text{JoyRL}$ 代码仓库上查看完整代码。我们主要看看更新策略的方式，如代码清单 $\text{12-1}$ 所示。
+
+
+ 代码清单 $\text{12-1}$ $\text{PPO}$ 算法更新
+
+
+```Python
+def update(self):
+ # 采样样本
+ old_states, old_actions, old_log_probs, old_rewards, old_dones = self.memory.sample()
+ # 转换成tensor
+ old_states = torch.tensor(np.array(old_states), device=self.device, dtype=torch.float32)
+ old_actions = torch.tensor(np.array(old_actions), device=self.device, dtype=torch.float32)
+ old_log_probs = torch.tensor(old_log_probs, device=self.device, dtype=torch.float32)
+ # 计算回报
+ returns = []
+ discounted_sum = 0
+ for reward, done in zip(reversed(old_rewards), reversed(old_dones)):
+ if done:
+ discounted_sum = 0
+ discounted_sum = reward + (self.gamma * discounted_sum)
+ returns.insert(0, discounted_sum)
+ # 归一化
+ returns = torch.tensor(returns, device=self.device, dtype=torch.float32)
+ returns = (returns - returns.mean()) / (returns.std() + 1e-5) # 1e-5 to avoid division by zero
+ for _ in range(self.k_epochs): # 小批量随机下降
+ # 计算优势
+ values = self.critic(old_states)
+ advantage = returns - values.detach()
+ probs = self.actor(old_states)
+ dist = Categorical(probs)
+ new_probs = dist.log_prob(old_actions)
+ # 计算重要性权重
+ ratio = torch.exp(new_probs - old_log_probs) #
+ surr1 = ratio * advantage
+ surr2 = torch.clamp(ratio, 1 - self.eps_clip, 1 + self.eps_clip) * advantage
+ # 注意dist.entropy().mean()的目的是最大化策略熵
+ actor_loss = -torch.min(surr1, surr2).mean() + self.entropy_coef * dist.entropy().mean()
+ critic_loss = (returns - values).pow(2).mean()
+ # 反向传播
+ self.actor_optimizer.zero_grad()
+ self.critic_optimizer.zero_grad()
+ actor_loss.backward()
+ critic_loss.backward()
+ self.actor_optimizer.step()
+ self.critic_optimizer.step()
+```
+
+$\qquad$ 注意在更新时由于每次采样的轨迹往往包含的样本数较多，我们通过利用小批量随机下降将样本随机切分成若干个部分，然后一个批量一个批量地更新网络参数。最后我们展示算法在 $\text{CartPole}$ 上的训练效果，如图 $\text{12-2}$ 所示。此外，在更新 $\text{Actor}$ 参数时，我们增加了一个最大化策略熵的正则项，这部分原理我们会在接下来的一章讲到。
+
+
+
+
图 $\text{12-2}$ $\text{CartPole}$ 环境 $\text{PPO}$ 算法训练曲线
+
+$\qquad$ 可以看到，与 $\text{A2C}$ 算法相比，$\text{PPO}$ 算法的收敛是要更加快速且稳定的。
\ No newline at end of file
diff --git a/docs/ch13/main.md b/docs/ch13/main.md
index 2b64b97..02345e6 100644
--- a/docs/ch13/main.md
+++ b/docs/ch13/main.md
@@ -1,8 +1,8 @@
-# SAC 算法
+# 第 13 章 SAC 算法
-$\qquad$ 本章开始介绍最后一种经典的策略梯度算法，即 $\text{Soft Actor-Critic}$ 算法，简写为 $\text{SAC}$ 。$\text{SAC}$ 算法是一种基于最大熵强化学习的策略梯度算法，它的目标是最大化策略的熵，从而使得策略更加鲁棒。$\text{SAC}$ 算法的核心思想是，通过最大化策略的熵，使得策略更加鲁棒，经过超参改良后的 $\text{SAC}$ 算法在稳定性方面是可以与 $\text{PPO}$ 算法华山论剑的。注意，由于 $\text{SAC}$ 算法理论相对之前的算法要复杂一些，因此推导过程要多很多，但是最后的结果还是相对简洁的，因此读者可以根据自己的需求选择性阅读，只需要关注伪代码中变量的涵义以及结果公式即可。
+$\qquad$ 本章开始介绍最后一种经典的策略梯度算法，即 $\text{Soft Actor-Critic}$ 算法，简写为 $\text{SAC}$ 。相比于前两个算法，$\text{SAC}$ 算法要更为复杂，因此本章涉及的公式推导也要多很多，但是最后的结果还是相对简洁的。因此读者可以根据自己的需求选择性阅读，只需要关注伪代码中变量的涵义以及结果公式即可。$\text{SAC}$ 算法是一种基于最大熵强化学习的策略梯度算法，它的目标是最大化策略的熵，从而使得策略更加鲁棒。$\text{SAC}$ 算法的核心思想是，通过最大化策略的熵，使得策略更加鲁棒，经过超参改良后的 $\text{SAC}$ 算法在稳定性方面是可以与 $\text{PPO}$ 算法华山论剑的。注意，由于 $\text{SAC}$ 算法理论相对之前的算法要复杂一些，因此推导过程
-## 最大熵强化学习
+## 13.1 最大熵强化学习
$\qquad$ 由于 $\text{SAC}$ 算法相比于之前的策略梯度算法独具一路，它走的是最大熵强化学习的路子。为了让读者更好地搞懂什么是 $\text{SAC}$ ，我们先介绍一下最大熵强化学习，然后从基于价值的 $\text{Soft Q-Learning}$ 算法开始讲起。我们先回忆一下确定性策略和随机性策略，确定性策略是指在给定相同状态下，总是选择相同的动作，随机性策略则是在给定状态下可以选择多种可能的动作，不知道读者们有没有想过这两种策略在实践中有什么优劣呢？或者说哪种更好呢？这里我们先架空实际的应用场景，只总结这两种策略本身的优劣，首先看确定性策略：
@@ -43,7 +43,7 @@ $$
$\qquad$ 它表示了随机策略 $\pi\left(\cdot \mid \mathbf{s}_t\right)$ 对应概率分布的随机程度，策略越随机，熵越大。后面我们可以发现，虽然理论推导起来比较复杂，但实际实践起来是比较简单的。
-## Soft Q-Learning
+## 13.2 Soft Q-Learning
$\qquad$ 前面小节中我们引入了带有熵的累积奖励期望，接下来我们需要基于这个重新定义的奖励来重新推导一下相关的量。后面我们会发现虽然推导起来比较复杂，但用代码实现起来是比较简单的，因为几乎跟传统的 $\text{Q-Learning}$ 算法没有多大区别。因此着重于实际应用的同学可以直接跳过本小节的推导部分，直接看后面的算法实战部分。
@@ -152,7 +152,7 @@ $$
\end{aligned}
$$
-## SAC
+## 13.3 SAC
$\qquad$ 实际上 $\text{SAC}$ 算法有两个版本，第一个版本是由 $\text{Tuomas Haarnoja}$ 于 $\text{2018}$ 年提出来的①，，第二个版本也是由 $\text{Tuomas Haarnoja}$ 于 $\text{2019}$ 年提出来的②，一般称作 $\text{SAC v2}$。第二个版本主要在前一版本的基础上做了简化，并且实现了温度因子的自动调节，从而使得算法更加简单稳定。
@@ -205,7 +205,7 @@ $$
\end{aligned}
$$
-## 自动调节温度因子
+## 13.4 自动调节温度因子
$\qquad$ 本小节主要讲解如何推导出自动调节因子的版本，整体推导的思路其实很简单，就是转换成规划问题，然后用动态规划、拉格朗日乘子法等方法简化求解，只关注结果的读者可以直接跳到本小节最后一个关于温度调节因子 $\alpha$ 的梯度下降公式即可。
@@ -361,4 +361,122 @@ $$
$\qquad$ 这样一来就能实现温度因子的自动调节了。这一版本由于引入了温度因子的自动调节，因此不需要额外的 $V$ 值网络，直接使用两个 $Q$ 网络（包含目标网络和当前网络）来作为 $\text{Critic}$ 估计价值即可。
-## 实战：SAC 算法
\ No newline at end of file
+## 13.5 实战：SAC 算法
+
+$\qquad$ 在实战中，我们主要讲解 $SAC$ 算法的第二个版本，即自动调节温度因子的版本。该版本的如图 $\text{13-1}$ 所示，整个训练过程相对来说还是比较简洁的，只是需要额外定义一些网络，比如用来调节温度因子等。
+
+
+
+
图 $\text{13-1}$ $\text{SAC}$ 算法伪代码
+
+### 15.5.1 定义模型
+
+$\qquad$ 首先我们定义 $\text{Actor}$ 和 $\text{Critic}$，即值网络和策略网络，跟 $\text{A2C}$ 算法其实是一样的，如代码清单 $\text{13-1}$ 所示。
+
+
+ 代码清单 $\text{13-1}$ $\text{Actor}$ 和 $\text{Critic}$ 网络
+
+
+```Python
+class ValueNet(nn.Module):
+ def __init__(self, state_dim, hidden_dim, init_w=3e-3):
+ super(ValueNet, self).__init__()
+ '''定义值网络
+ '''
+ self.linear1 = nn.Linear(state_dim, hidden_dim) # 输入层
+ self.linear2 = nn.Linear(hidden_dim, hidden_dim) # 隐藏层
+ self.linear3 = nn.Linear(hidden_dim, 1)
+
+ self.linear3.weight.data.uniform_(-init_w, init_w) # 初始化权重
+ self.linear3.bias.data.uniform_(-init_w, init_w)
+
+ def forward(self, state):
+ x = F.relu(self.linear1(state))
+ x = F.relu(self.linear2(x))
+ x = self.linear3(x)
+ return x
+class PolicyNet(nn.Module):
+ def __init__(self, state_dim, action_dim, hidden_dim, init_w=3e-3, log_std_min=-20, log_std_max=2):
+ super(PolicyNet, self).__init__()
+ self.log_std_min = log_std_min
+ self.log_std_max = log_std_max
+
+ self.linear1 = nn.Linear(state_dim, hidden_dim)
+ self.linear2 = nn.Linear(hidden_dim, hidden_dim)
+
+ # 初始化权重
+ self.mean_linear = nn.Linear(hidden_dim, action_dim)
+ self.mean_linear.weight.data.uniform_(-init_w, init_w)
+ self.mean_linear.bias.data.uniform_(-init_w, init_w)
+
+ self.log_std_linear = nn.Linear(hidden_dim, action_dim)
+ self.log_std_linear.weight.data.uniform_(-init_w, init_w)
+ self.log_std_linear.bias.data.uniform_(-init_w, init_w)
+
+ def forward(self, state):
+ x = F.relu(self.linear1(state))
+ x = F.relu(self.linear2(x))
+
+ mean = self.mean_linear(x)
+ log_std = self.log_std_linear(x)
+ log_std = torch.clamp(log_std, self.log_std_min, self.log_std_max)
+
+ return mean, log_std
+
+ def evaluate(self, state, epsilon=1e-6):
+ mean, log_std = self.forward(state)
+ std = log_std.exp()
+ # 计算动作
+ normal = Normal(mean, std)
+ z = normal.sample()
+ action = torch.tanh(z)
+ # 计算动作概率
+ log_prob = normal.log_prob(z) - torch.log(1 - action.pow(2) + epsilon)
+ log_prob = log_prob.sum(-1, keepdim=True)
+
+ return action, log_prob, z, mean, log_std
+
+ def get_action(self, state):
+ state = torch.FloatTensor(state).unsqueeze(0)
+ mean, log_std = self.forward(state)
+ std = log_std.exp()
+
+ normal = Normal(mean, std)
+ z = normal.sample()
+ action = torch.tanh(z)
+
+ action = action.detach().cpu().numpy()
+ return action[0]
+```
+
+$\qquad$ 然后再额外定义一个 $\text{Soft Q}$ 网络，如代码清单 $\text{13-2}$ 所示。
+
+
+ 代码清单 $\text{13-2}$ $\text{Soft Q}$ 网络
+
+
+```Python
+class SoftQNet(nn.Module):
+ def __init__(self, state_dim, action_dim, hidden_dim, init_w=3e-3):
+ super(SoftQNet, self).__init__()
+ '''定义Q网络，state_dim, action_dim, hidden_dim, init_w分别为状态维度、动作维度隐藏层维度和初始化权重
+ '''
+ self.linear1 = nn.Linear(state_dim + action_dim, hidden_dim)
+ self.linear2 = nn.Linear(hidden_dim, hidden_dim)
+ self.linear3 = nn.Linear(hidden_dim, 1)
+
+ self.linear3.weight.data.uniform_(-init_w, init_w)
+ self.linear3.bias.data.uniform_(-init_w, init_w)
+
+ def forward(self, state, action):
+ x = torch.cat([state, action], 1)
+ x = F.relu(self.linear1(x))
+ x = F.relu(self.linear2(x))
+ x = self.linear3(x)
+ return x
+```
+
+### 15.5.2 算法更新
+
+$\qquad$ 我们再看看
\ No newline at end of file
diff --git a/docs/figs/ch12/PPO_Cartpole_training_curve.png b/docs/figs/ch12/PPO_Cartpole_training_curve.png
new file mode 100644
index 0000000..d4b4bf8
Binary files /dev/null and b/docs/figs/ch12/PPO_Cartpole_training_curve.png differ
diff --git a/docs/figs/ch12/ppo_pseu.png b/docs/figs/ch12/ppo_pseu.png
new file mode 100644
index 0000000..c1bba91
Binary files /dev/null and b/docs/figs/ch12/ppo_pseu.png differ
diff --git a/docs/figs/ch13/sac_pseu.png b/docs/figs/ch13/sac_pseu.png
new file mode 100644
index 0000000..67f2f91
Binary files /dev/null and b/docs/figs/ch13/sac_pseu.png differ
diff --git a/notebooks/PPO.ipynb b/notebooks/PPO.ipynb
new file mode 100644
index 0000000..94cadae
--- /dev/null
+++ b/notebooks/PPO.ipynb
@@ -0,0 +1,522 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# PPO实现CarPole-v1（离散动作空间）"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 1. 定义算法"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 1.1 定义模型"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 57,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import torch.nn as nn\n",
+ "import torch.nn.functional as F\n",
+ "class ActorSoftmax(nn.Module):\n",
+ " def __init__(self, input_dim, output_dim, hidden_dim=256):\n",
+ " super(ActorSoftmax, self).__init__()\n",
+ " self.fc1 = nn.Linear(input_dim, hidden_dim)\n",
+ " self.fc2 = nn.Linear(hidden_dim, hidden_dim)\n",
+ " self.fc3 = nn.Linear(hidden_dim, output_dim)\n",
+ " def forward(self,x):\n",
+ " x = F.relu(self.fc1(x))\n",
+ " x = F.relu(self.fc2(x))\n",
+ " probs = F.softmax(self.fc3(x),dim=1)\n",
+ " return probs\n",
+ "class Critic(nn.Module):\n",
+ " def __init__(self,input_dim,output_dim,hidden_dim=256):\n",
+ " super(Critic,self).__init__()\n",
+ " assert output_dim == 1 # critic must output a single value\n",
+ " self.fc1 = nn.Linear(input_dim, hidden_dim)\n",
+ " self.fc2 = nn.Linear(hidden_dim, hidden_dim)\n",
+ " self.fc3 = nn.Linear(hidden_dim, output_dim)\n",
+ " def forward(self,x):\n",
+ " x = F.relu(self.fc1(x))\n",
+ " x = F.relu(self.fc2(x))\n",
+ " value = self.fc3(x)\n",
+ " return value"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 1.2 定义经验回放"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 58,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import random\n",
+ "from collections import deque\n",
+ "class ReplayBufferQue:\n",
+ " '''DQN的经验回放池，每次采样batch_size个样本'''\n",
+ " def __init__(self, capacity: int) -> None:\n",
+ " self.capacity = capacity\n",
+ " self.buffer = deque(maxlen=self.capacity)\n",
+ " def push(self,transitions):\n",
+ " '''_summary_\n",
+ " Args:\n",
+ " trainsitions (tuple): _description_\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: # sequential sampling\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",
+ " self.buffer.clear()\n",
+ " def __len__(self):\n",
+ " return len(self.buffer)\n",
+ "\n",
+ "class PGReplay(ReplayBufferQue):\n",
+ " '''PG的经验回放池，每次采样所有样本，因此只需要继承ReplayBufferQue，重写sample方法即可\n",
+ " '''\n",
+ " def __init__(self):\n",
+ " self.buffer = deque()\n",
+ " def sample(self):\n",
+ " ''' sample all the transitions\n",
+ " '''\n",
+ " batch = list(self.buffer)\n",
+ " return zip(*batch)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 1.3 定义智能体"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 59,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import torch\n",
+ "from torch.distributions import Categorical\n",
+ "class Agent:\n",
+ " def __init__(self,cfg) -> None:\n",
+ " \n",
+ " self.gamma = cfg.gamma\n",
+ " self.device = torch.device(cfg.device) \n",
+ " self.actor = ActorSoftmax(cfg.n_states,cfg.n_actions, hidden_dim = cfg.actor_hidden_dim).to(self.device)\n",
+ " self.critic = Critic(cfg.n_states,1,hidden_dim=cfg.critic_hidden_dim).to(self.device)\n",
+ " self.actor_optimizer = torch.optim.Adam(self.actor.parameters(), lr=cfg.actor_lr)\n",
+ " self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), lr=cfg.critic_lr)\n",
+ " self.memory = PGReplay()\n",
+ " self.k_epochs = cfg.k_epochs # update policy for K epochs\n",
+ " self.eps_clip = cfg.eps_clip # clip parameter for PPO\n",
+ " self.entropy_coef = cfg.entropy_coef # entropy coefficient\n",
+ " self.sample_count = 0\n",
+ " self.update_freq = cfg.update_freq\n",
+ "\n",
+ " def sample_action(self,state):\n",
+ " self.sample_count += 1\n",
+ " state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
+ " probs = self.actor(state)\n",
+ " dist = Categorical(probs)\n",
+ " action = dist.sample()\n",
+ " self.log_probs = dist.log_prob(action).detach()\n",
+ " return action.detach().cpu().numpy().item()\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",
+ " probs = self.actor(state)\n",
+ " dist = Categorical(probs)\n",
+ " action = dist.sample()\n",
+ " return action.detach().cpu().numpy().item()\n",
+ " def update(self):\n",
+ " # update policy every n steps\n",
+ " if self.sample_count % self.update_freq != 0:\n",
+ " return\n",
+ " # print(\"update policy\")\n",
+ " old_states, old_actions, old_log_probs, old_rewards, old_dones = self.memory.sample()\n",
+ " # convert to tensor\n",
+ " old_states = torch.tensor(np.array(old_states), device=self.device, dtype=torch.float32)\n",
+ " old_actions = torch.tensor(np.array(old_actions), device=self.device, dtype=torch.float32)\n",
+ " old_log_probs = torch.tensor(old_log_probs, device=self.device, dtype=torch.float32)\n",
+ " # monte carlo estimate of state rewards\n",
+ " returns = []\n",
+ " discounted_sum = 0\n",
+ " for reward, done in zip(reversed(old_rewards), reversed(old_dones)):\n",
+ " if done:\n",
+ " discounted_sum = 0\n",
+ " discounted_sum = reward + (self.gamma * discounted_sum)\n",
+ " returns.insert(0, discounted_sum)\n",
+ " # Normalizing the rewards:\n",
+ " returns = torch.tensor(returns, device=self.device, dtype=torch.float32)\n",
+ " returns = (returns - returns.mean()) / (returns.std() + 1e-5) # 1e-5 to avoid division by zero\n",
+ " for _ in range(self.k_epochs):\n",
+ " # compute advantage\n",
+ " values = self.critic(old_states) # detach to avoid backprop through the critic\n",
+ " advantage = returns - values.detach()\n",
+ " # get action probabilities\n",
+ " probs = self.actor(old_states)\n",
+ " dist = Categorical(probs)\n",
+ " # get new action probabilities\n",
+ " new_probs = dist.log_prob(old_actions)\n",
+ " # compute ratio (pi_theta / pi_theta__old):\n",
+ " ratio = torch.exp(new_probs - old_log_probs) # old_log_probs must be detached\n",
+ " # compute surrogate loss\n",
+ " surr1 = ratio * advantage\n",
+ " surr2 = torch.clamp(ratio, 1 - self.eps_clip, 1 + self.eps_clip) * advantage\n",
+ " # compute actor loss\n",
+ " actor_loss = -torch.min(surr1, surr2).mean() + self.entropy_coef * dist.entropy().mean()\n",
+ " # compute critic loss\n",
+ " critic_loss = (returns - values).pow(2).mean()\n",
+ " # take gradient step\n",
+ " self.actor_optimizer.zero_grad()\n",
+ " self.critic_optimizer.zero_grad()\n",
+ " actor_loss.backward()\n",
+ " critic_loss.backward()\n",
+ " self.actor_optimizer.step()\n",
+ " self.critic_optimizer.step()\n",
+ " self.memory.clear()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 2. 定义训练"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 60,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import copy\n",
+ "def train(cfg, env, agent):\n",
+ " ''' 训练\n",
+ " '''\n",
+ " print(\"开始训练！\")\n",
+ " rewards = [] # 记录所有回合的奖励\n",
+ " steps = []\n",
+ " best_ep_reward = 0 # 记录最大回合奖励\n",
+ " output_agent = None\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,agent.log_probs,reward,done)) # 保存transition\n",
+ " state = next_state # 更新下一个状态\n",
+ " agent.update() # 更新智能体\n",
+ " ep_reward += reward # 累加奖励\n",
+ " if done:\n",
+ " break\n",
+ " if (i_ep+1)%cfg.eval_per_episode == 0:\n",
+ " sum_eval_reward = 0\n",
+ " for _ in range(cfg.eval_eps):\n",
+ " eval_ep_reward = 0\n",
+ " state = env.reset()\n",
+ " for _ in range(cfg.max_steps):\n",
+ " action = agent.predict_action(state) # 选择动作\n",
+ " next_state, reward, done, _ = env.step(action) # 更新环境，返回transition\n",
+ " state = next_state # 更新下一个状态\n",
+ " eval_ep_reward += reward # 累加奖励\n",
+ " if done:\n",
+ " break\n",
+ " sum_eval_reward += eval_ep_reward\n",
+ " mean_eval_reward = sum_eval_reward/cfg.eval_eps\n",
+ " if mean_eval_reward >= best_ep_reward:\n",
+ " best_ep_reward = mean_eval_reward\n",
+ " output_agent = copy.deepcopy(agent)\n",
+ " print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}，评估奖励：{mean_eval_reward:.2f}，最佳评估奖励：{best_ep_reward:.2f}，更新模型！\")\n",
+ " else:\n",
+ " print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}，评估奖励：{mean_eval_reward:.2f}，最佳评估奖励：{best_ep_reward:.2f}\")\n",
+ " steps.append(ep_step)\n",
+ " rewards.append(ep_reward)\n",
+ " print(\"完成训练！\")\n",
+ " env.close()\n",
+ " return output_agent,{'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": 61,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import gym\n",
+ "import os\n",
+ "import numpy as np\n",
+ "def all_seed(env,seed = 1):\n",
+ " ''' 万能的seed函数\n",
+ " '''\n",
+ " if seed == 0:\n",
+ " return\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",
+ " 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_states和n_actions到cfg参数中\n",
+ " setattr(cfg, 'n_states', n_states)\n",
+ " setattr(cfg, 'n_actions', n_actions) \n",
+ " agent = Agent(cfg)\n",
+ " return env,agent"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 4. 设置参数"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 62,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "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 = False # 是否用gym的新api\n",
+ " self.algo_name = \"PPO\" # 算法名字\n",
+ " self.mode = \"train\" # train or test\n",
+ " self.seed = 1 # 随机种子\n",
+ " self.device = \"cuda\" # device to use\n",
+ " self.train_eps = 200 # 训练的回合数\n",
+ " self.test_eps = 20 # 测试的回合数\n",
+ " self.max_steps = 200 # 每个回合的最大步数\n",
+ " self.eval_eps = 5 # 评估的回合数\n",
+ " self.eval_per_episode = 10 # 评估的频率\n",
+ "\n",
+ " self.gamma = 0.99 # 折扣因子\n",
+ " self.k_epochs = 4 # 更新策略网络的次数\n",
+ " self.actor_lr = 0.0003 # actor网络的学习率\n",
+ " self.critic_lr = 0.0003 # critic网络的学习率\n",
+ " self.eps_clip = 0.2 # epsilon-clip\n",
+ " self.entropy_coef = 0.01 # entropy的系数\n",
+ " self.update_freq = 100 # 更新频率\n",
+ " self.actor_hidden_dim = 256 # actor网络的隐藏层维度\n",
+ " self.critic_hidden_dim = 256 # critic网络的隐藏层维度\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()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 5. 开始训练"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 63,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "状态空间维度：4，动作空间维度：2\n",
+ "开始训练！\n",
+ "回合：10/200，奖励：11.00，评估奖励：29.20，最佳评估奖励：29.20，更新模型！\n",
+ "回合：20/200，奖励：68.00，评估奖励：25.00，最佳评估奖励：29.20\n",
+ "回合：30/200，奖励：60.00，评估奖励：26.20，最佳评估奖励：29.20\n",
+ "回合：40/200，奖励：105.00，评估奖励：27.60，最佳评估奖励：29.20\n",
+ "回合：50/200，奖励：26.00，评估奖励：60.60，最佳评估奖励：60.60，更新模型！\n",
+ "回合：60/200，奖励：122.00，评估奖励：113.40，最佳评估奖励：113.40，更新模型！\n",
+ "回合：70/200，奖励：65.00，评估奖励：38.00，最佳评估奖励：113.40\n",
+ "回合：80/200，奖励：175.00，评估奖励：135.40，最佳评估奖励：135.40，更新模型！\n",
+ "回合：90/200，奖励：200.00，评估奖励：177.20，最佳评估奖励：177.20，更新模型！\n",
+ "回合：100/200，奖励：115.00，评估奖励：173.60，最佳评估奖励：177.20\n",
+ "回合：110/200，奖励：200.00，评估奖励：183.20，最佳评估奖励：183.20，更新模型！\n",
+ "回合：120/200，奖励：196.00，评估奖励：173.60，最佳评估奖励：183.20\n",
+ "回合：130/200，奖励：46.00，评估奖励：61.40，最佳评估奖励：183.20\n",
+ "回合：140/200，奖励：200.00，评估奖励：166.40，最佳评估奖励：183.20\n",
+ "回合：150/200，奖励：172.00，评估奖励：154.40，最佳评估奖励：183.20\n",
+ "回合：160/200，奖励：61.00，评估奖励：84.80，最佳评估奖励：183.20\n",
+ "回合：170/200，奖励：127.00，评估奖励：181.60，最佳评估奖励：183.20\n",
+ "回合：180/200，奖励：152.00，评估奖励：173.20，最佳评估奖励：183.20\n",
+ "回合：190/200，奖励：200.00，评估奖励：200.00，最佳评估奖励：200.00，更新模型！\n",
+ "回合：200/200，奖励：176.00，评估奖励：190.20，最佳评估奖励：200.00\n",
+ "完成训练！\n",
+ "开始测试！\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"
+ },
+ {
+ "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",
+ "best_agent,res_dic = train(cfg, env, agent)\n",
+ " \n",
+ "plot_rewards(res_dic['rewards'], cfg, tag=\"train\") \n",
+ "# 测试\n",
+ "res_dic = test(cfg, env, best_agent)\n",
+ "plot_rewards(res_dic['rewards'], cfg, tag=\"test\") # 画出结果"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3.7.12 ('easyrl')",
+ "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.12"
+ },
+ "orig_nbformat": 4,
+ "vscode": {
+ "interpreter": {
+ "hash": "f5a9629e9f3b9957bf68a43815f911e93447d47b3d065b6a8a04975e44c504d9"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/notebooks/SAC.ipynb b/notebooks/SAC.ipynb
new file mode 100644
index 0000000..9ed14f9
--- /dev/null
+++ b/notebooks/SAC.ipynb
@@ -0,0 +1,588 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 86,
+ "id": "6218efae",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import torch\n",
+ "import torch.nn as nn\n",
+ "import torch.nn.functional as F\n",
+ "from torch.optim import Adam\n",
+ "from torch.distributions import Normal\n",
+ "import random\n",
+ "import numpy as np\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8a207689",
+ "metadata": {},
+ "source": [
+ "## 1.定义算法\n",
+ "### 1.1 建立Q网络和策略网络"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 75,
+ "id": "5955151d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class ValueNet(nn.Module):\n",
+ " def __init__(self, state_dim, hidden_dim, init_w=3e-3):\n",
+ " super(ValueNet, self).__init__()\n",
+ " '''定义值网络\n",
+ " '''\n",
+ " self.linear1 = nn.Linear(state_dim, hidden_dim) # 输入层\n",
+ " self.linear2 = nn.Linear(hidden_dim, hidden_dim) # 隐藏层\n",
+ " self.linear3 = nn.Linear(hidden_dim, 1)\n",
+ "\n",
+ " self.linear3.weight.data.uniform_(-init_w, init_w) # 初始化权重\n",
+ " self.linear3.bias.data.uniform_(-init_w, init_w)\n",
+ " \n",
+ " def forward(self, state):\n",
+ " x = F.relu(self.linear1(state))\n",
+ " x = F.relu(self.linear2(x))\n",
+ " x = self.linear3(x)\n",
+ " return x\n",
+ " \n",
+ " \n",
+ "class SoftQNet(nn.Module):\n",
+ " def __init__(self, state_dim, action_dim, hidden_dim, init_w=3e-3):\n",
+ " super(SoftQNet, self).__init__()\n",
+ " '''定义Q网络，state_dim, action_dim, hidden_dim, init_w分别为状态维度、动作维度隐藏层维度和初始化权重\n",
+ " '''\n",
+ " self.linear1 = nn.Linear(state_dim + action_dim, hidden_dim)\n",
+ " self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
+ " self.linear3 = nn.Linear(hidden_dim, 1)\n",
+ " \n",
+ " self.linear3.weight.data.uniform_(-init_w, init_w)\n",
+ " self.linear3.bias.data.uniform_(-init_w, init_w)\n",
+ " \n",
+ " def forward(self, state, action):\n",
+ " x = torch.cat([state, action], 1)\n",
+ " x = F.relu(self.linear1(x))\n",
+ " x = F.relu(self.linear2(x))\n",
+ " x = self.linear3(x)\n",
+ " return x\n",
+ " \n",
+ " \n",
+ "class PolicyNet(nn.Module):\n",
+ " def __init__(self, state_dim, action_dim, hidden_dim, init_w=3e-3, log_std_min=-20, log_std_max=2):\n",
+ " super(PolicyNet, self).__init__()\n",
+ " self.log_std_min = log_std_min\n",
+ " self.log_std_max = log_std_max\n",
+ " \n",
+ " self.linear1 = nn.Linear(state_dim, hidden_dim)\n",
+ " self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
+ " \n",
+ " # 初始化权重\n",
+ " self.mean_linear = nn.Linear(hidden_dim, action_dim)\n",
+ " self.mean_linear.weight.data.uniform_(-init_w, init_w)\n",
+ " self.mean_linear.bias.data.uniform_(-init_w, init_w)\n",
+ " \n",
+ " self.log_std_linear = nn.Linear(hidden_dim, action_dim)\n",
+ " self.log_std_linear.weight.data.uniform_(-init_w, init_w)\n",
+ " self.log_std_linear.bias.data.uniform_(-init_w, init_w)\n",
+ " \n",
+ " def forward(self, state):\n",
+ " x = F.relu(self.linear1(state))\n",
+ " x = F.relu(self.linear2(x))\n",
+ " \n",
+ " mean = self.mean_linear(x)\n",
+ " log_std = self.log_std_linear(x)\n",
+ " log_std = torch.clamp(log_std, self.log_std_min, self.log_std_max)\n",
+ " \n",
+ " return mean, log_std\n",
+ " \n",
+ " def evaluate(self, state, epsilon=1e-6):\n",
+ " mean, log_std = self.forward(state)\n",
+ " std = log_std.exp()\n",
+ " # 计算动作\n",
+ " normal = Normal(mean, std)\n",
+ " z = normal.sample()\n",
+ " action = torch.tanh(z)\n",
+ " # 计算动作概率\n",
+ " log_prob = normal.log_prob(z) - torch.log(1 - action.pow(2) + epsilon)\n",
+ " log_prob = log_prob.sum(-1, keepdim=True)\n",
+ " \n",
+ " return action, log_prob, z, mean, log_std\n",
+ " \n",
+ " def get_action(self, state):\n",
+ " state = torch.FloatTensor(state).unsqueeze(0)\n",
+ " mean, log_std = self.forward(state)\n",
+ " std = log_std.exp()\n",
+ " \n",
+ " normal = Normal(mean, std)\n",
+ " z = normal.sample()\n",
+ " action = torch.tanh(z)\n",
+ " \n",
+ " action = action.detach().cpu().numpy()\n",
+ " return action[0]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "debce530",
+ "metadata": {},
+ "source": [
+ "### 1.2 定义经验回放池"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 76,
+ "id": "1c740ca0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class ReplayBuffer:\n",
+ " def __init__(self, capacity):\n",
+ " self.capacity = capacity # 经验回放的容量\n",
+ " self.buffer = [] # 缓冲区\n",
+ " self.position = 0 \n",
+ " \n",
+ " def push(self, state, action, reward, next_state, done):\n",
+ " ''' 缓冲区是一个队列，容量超出时去掉开始存入的转移(transition)\n",
+ " '''\n",
+ " if len(self.buffer) < self.capacity:\n",
+ " self.buffer.append(None)\n",
+ " self.buffer[self.position] = (state, action, reward, next_state, done)\n",
+ " self.position = (self.position + 1) % self.capacity \n",
+ " \n",
+ " def sample(self, batch_size):\n",
+ " batch = random.sample(self.buffer, batch_size) # 随机采出小批量转移\n",
+ " state, action, reward, next_state, done = zip(*batch) # 解压成状态，动作等\n",
+ " return state, action, reward, next_state, done\n",
+ " \n",
+ " def __len__(self):\n",
+ " ''' 返回当前存储的量\n",
+ " '''\n",
+ " return len(self.buffer)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "32a65b71",
+ "metadata": {},
+ "source": [
+ "### 1.3 SAC算法"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 77,
+ "id": "5a86f725",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class SAC:\n",
+ " def __init__(self,cfg) -> None:\n",
+ " self.state_dim = cfg.state_dim\n",
+ " self.action_dim = cfg.action_dim\n",
+ " self.batch_size = cfg.batch_size \n",
+ " self.memory = ReplayBuffer(cfg.capacity)\n",
+ " self.device = cfg.device\n",
+ " self.action_space = cfg.action_space\n",
+ " self.value_net = ValueNet(self.state_dim, cfg.hidden_dim).to(self.device)\n",
+ " self.target_value_net = ValueNet(self.state_dim, cfg.hidden_dim).to(self.device)\n",
+ " self.soft_q_net = SoftQNet(self.state_dim, self.action_dim, cfg.hidden_dim).to(self.device)\n",
+ " self.policy_net = PolicyNet(self.state_dim, self.action_dim, cfg.hidden_dim).to(self.device) \n",
+ " self.value_optimizer = Adam(self.value_net.parameters(), lr=cfg.value_lr)\n",
+ " self.soft_q_optimizer = Adam(self.soft_q_net.parameters(), lr=cfg.soft_q_lr)\n",
+ " self.policy_optimizer = Adam(self.policy_net.parameters(), lr=cfg.policy_lr) \n",
+ " for target_param, param in zip(self.target_value_net.parameters(), self.value_net.parameters()):\n",
+ " target_param.data.copy_(param.data)\n",
+ " self.value_criterion = nn.MSELoss()\n",
+ " self.soft_q_criterion = nn.MSELoss()\n",
+ " def update(self, gamma=0.99,mean_lambda=1e-3,\n",
+ " std_lambda=1e-3,\n",
+ " z_lambda=0.0,\n",
+ " soft_tau=1e-2,\n",
+ " ):\n",
+ " if len(self.memory) < self.batch_size: # 当经验回放中不满足一个批量时，不更新策略\n",
+ " return \n",
+ " state, action, reward, next_state, done = self.memory.sample(self.batch_size) # 从经验回放中随机采样一个批量的转移(transition)\n",
+ " # 将数据转换为tensor\n",
+ " state = torch.FloatTensor(state).to(self.device)\n",
+ " next_state = torch.FloatTensor(next_state).to(self.device)\n",
+ " action = torch.FloatTensor(action).to(self.device)\n",
+ " reward = torch.FloatTensor(reward).unsqueeze(1).to(self.device)\n",
+ " done = torch.FloatTensor(np.float32(done)).unsqueeze(1).to(self.device)\n",
+ " \n",
+ " expected_q_value = self.soft_q_net(state, action) #计算t时刻的状态-动作Q值\n",
+ " expected_value = self.value_net(state) #计算t时刻的状态值\n",
+ " new_action, log_prob, z, mean, log_std = self.policy_net.evaluate(state) #计算t时刻的动作、动作似然概率、正态分布抽样、分布均值和标准差\n",
+ "\n",
+ " target_value = self.target_value_net(next_state) #计算t+1时刻的状态值\n",
+ " next_q_value = reward + (1 - done) * gamma * target_value # 时序差分计算t+1时刻的Q值\n",
+ " # JQ = 𝔼(st,at)~D[0.5(Q1(st,at) - r(st,at) - γ(𝔼st+1~p[V(st+1)]))^2]\n",
+ " q_value_loss = nn.MSELoss()(expected_q_value, next_q_value.detach()) #计算q网络的损失函数\n",
+ "\n",
+ " expected_new_q_value = self.soft_q_net(state, new_action) #计算t时刻动作对应的q值\n",
+ " next_value = expected_new_q_value - log_prob # 计算t时刻的v值\n",
+ " value_loss = nn.MSELoss()(expected_value, next_value.detach()) #计算值网络损失函数\n",
+ " \n",
+ " ## 计算策略损失\n",
+ " log_prob_target = expected_new_q_value - expected_value \n",
+ " # Jπ = 𝔼st∼D,εt∼N[α * logπ(f(εt;st)|st) − Q(st,f(εt;st))]\n",
+ " policy_loss = (log_prob * (log_prob - log_prob_target).detach()).mean()\n",
+ "\n",
+ " ## 计算reparameterization参数损失\n",
+ " mean_loss = mean_lambda * mean.pow(2).mean()\n",
+ " std_loss = std_lambda * log_std.pow(2).mean()\n",
+ " z_loss = z_lambda * z.pow(2).sum(1).mean()\n",
+ "\n",
+ " policy_loss += mean_loss + std_loss + z_loss\n",
+ "\n",
+ " self.soft_q_optimizer.zero_grad()\n",
+ " q_value_loss.backward()\n",
+ " self.soft_q_optimizer.step()\n",
+ "\n",
+ " self.value_optimizer.zero_grad()\n",
+ " value_loss.backward()\n",
+ " self.value_optimizer.step()\n",
+ "\n",
+ " self.policy_optimizer.zero_grad()\n",
+ " policy_loss.backward()\n",
+ " self.policy_optimizer.step()\n",
+ " ## 软更新目标值网络参数\n",
+ " for target_param, param in zip(self.target_value_net.parameters(), self.value_net.parameters()):\n",
+ " target_param.data.copy_(\n",
+ " target_param.data * (1.0 - soft_tau) + param.data * soft_tau\n",
+ " )\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e2581771",
+ "metadata": {},
+ "source": [
+ "## 2.模型训练与测试"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 78,
+ "id": "0a3e3413",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def train(cfg, env, agent):\n",
+ " print(\"开始训练！\")\n",
+ " rewards = [] # 记录所有回合的奖励\n",
+ " for i_ep in range(cfg.train_eps):\n",
+ " state = env.reset() # 重置环境，返回初始状态\n",
+ " ep_reward = 0 # 记录一回合内的奖励\n",
+ " for i_step in range(cfg.max_steps):\n",
+ " action = agent.policy_net.get_action(state) # 抽样动作\n",
+ " next_state, reward, terminated, info = env.step(action) # 更新环境，返回transitions\n",
+ " agent.memory.push(state, action, reward,next_state, terminated) # 保存transition\n",
+ " agent.update() # 更新智能体\n",
+ " state = next_state # 更新下一个状态\n",
+ " ep_reward += reward # 累加奖励\n",
+ " if terminated:\n",
+ " break\n",
+ " if (i_ep+1)%10 == 0:\n",
+ " print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}\")\n",
+ " rewards.append(ep_reward)\n",
+ " print(\"完成训练！\")\n",
+ " return {'rewards':rewards}\n",
+ "def test(cfg, env, agent):\n",
+ " print(\"开始测试！\")\n",
+ " rewards = [] # 记录所有回合的奖励\n",
+ " for i_ep in range(cfg.test_eps):\n",
+ " state = env.reset() # 重置环境，返回初始状态\n",
+ " ep_reward = 0\n",
+ " for i_step in range(cfg.max_steps):\n",
+ " action = agent.policy_net.get_action(state) # 抽样动作\n",
+ " next_state, reward, terminated, info = env.step(action) # 更新环境，返回transitions\n",
+ " state = next_state # 更新下一个状态\n",
+ " ep_reward += reward # 累加奖励\n",
+ " if terminated:\n",
+ " break\n",
+ " rewards.append(ep_reward)\n",
+ " print(f\"回合：{i_ep+1}/{cfg.test_eps}，奖励：{ep_reward:.2f}\")\n",
+ " print(\"完成测试！\")\n",
+ " return {'rewards':rewards}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d4d45832",
+ "metadata": {},
+ "source": [
+ "## 3.定义环境"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 79,
+ "id": "15b94efa",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import gym\n",
+ "import os\n",
+ "import numpy as np\n",
+ "\n",
+ "class NormalizedActions(gym.ActionWrapper):\n",
+ " def action(self, action):\n",
+ " low = self.action_space.low\n",
+ " high = self.action_space.high\n",
+ " \n",
+ " action = low + (action + 1.0) * 0.5 * (high - low)\n",
+ " action = np.clip(action, low, high)\n",
+ " \n",
+ " return action\n",
+ "\n",
+ " def reverse_action(self, action):\n",
+ " low = self.action_space.low\n",
+ " high = self.action_space.high\n",
+ " action = 2 * (action - low) / (high - low) - 1\n",
+ " action = np.clip(action, low, high)\n",
+ " return action\n",
+ " \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 = NormalizedActions(gym.make(cfg.env_name)) # 创建环境\n",
+ " all_seed(env,seed=cfg.seed)\n",
+ " state_dim = env.observation_space.shape[0]\n",
+ " action_dim = env.action_space.shape[0]\n",
+ " print(f\"状态空间维度：{state_dim}，动作空间维度：{action_dim}\")\n",
+ " # 更新state_dim和action_dim到cfg参数中\n",
+ " setattr(cfg, 'state_dim', state_dim)\n",
+ " setattr(cfg, 'action_dim', action_dim) \n",
+ " setattr(cfg, 'action_space', env.action_space) \n",
+ " agent = SAC(cfg)\n",
+ " return env,agent"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "87423249",
+ "metadata": {},
+ "source": [
+ "## 4.设置参数"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 84,
+ "id": "fbd710ef",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import argparse\n",
+ "import matplotlib.pyplot as plt\n",
+ "import seaborn as sns\n",
+ "class Config:\n",
+ " def __init__(self):\n",
+ " self.algo_name = 'SAC'\n",
+ " self.env_name = 'Pendulum-v1'\n",
+ " self.seed = 50 # 随机种子\n",
+ " self.train_eps = 400 # 训练迭代次数\n",
+ " self.test_eps = 10 # 测试迭代次数\n",
+ " self.eval_eps = 10 # 评估迭代次数\n",
+ " self.max_steps = 200 # 每次迭代最大时间步\n",
+ " self.gamma = 0.99 #折扣因子\n",
+ " self.mean_lambda=1e-3 # 重参数化分布均值的损失权重\n",
+ " self.std_lambda=1e-3 # 重参数化分布标准差的损失权重\n",
+ " self.z_lambda=0.0 # 重参数化分布抽样值的损失权重\n",
+ " self.soft_tau=1e-2 # 目标网络软更新系数\n",
+ " self.value_lr = 3e-4 # 值网络的学习率\n",
+ " self.soft_q_lr = 3e-4 # Q网络的学习率\n",
+ " self.policy_lr = 3e-4 # 策略网络的学习率\n",
+ " self.capacity = 1000000 # 经验缓存池的大小\n",
+ " self.hidden_dim = 256 # 隐藏层维度\n",
+ " self.batch_size = 128 # 批次大小\n",
+ " self.start_steps = 1000 # 利用前的探索步数\n",
+ " self.buffer_size = 1000000 # 经验回放池大小\n",
+ " self.device=torch.device(\"cpu\") # 使用设备\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,title=\"learning curve\"):\n",
+ " sns.set()\n",
+ " plt.figure() # 创建一个图形实例，方便同时多画几个图\n",
+ " plt.title(f\"{title}\")\n",
+ " plt.xlim(0, len(rewards), 10) # 设置x轴的范围\n",
+ " plt.xlabel('epsiodes')\n",
+ " plt.plot(rewards, label='rewards')\n",
+ " plt.plot(smooth(rewards), label='smoothed')\n",
+ " plt.legend()\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2bc3f1c6",
+ "metadata": {},
+ "source": [
+ "## 5.开始训练"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 85,
+ "id": "80de3242",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "状态空间维度：3，动作空间维度：1\n",
+ "开始训练！\n",
+ "回合：10/400，奖励：-1165.43\n",
+ "回合：20/400，奖励：-994.18\n",
+ "回合：30/400，奖励：-634.86\n",
+ "回合：40/400，奖励：-883.46\n",
+ "回合：50/400，奖励：-745.16\n",
+ "回合：60/400，奖励：-617.77\n",
+ "回合：70/400，奖励：-0.98\n",
+ "回合：80/400，奖励：-386.85\n",
+ "回合：90/400，奖励：-245.64\n",
+ "回合：100/400，奖励：-118.91\n",
+ "回合：110/400，奖励：-250.71\n",
+ "回合：120/400，奖励：-245.33\n",
+ "回合：130/400，奖励：-125.58\n",
+ "回合：140/400，奖励：-124.50\n",
+ "回合：150/400，奖励：-121.64\n",
+ "回合：160/400，奖励：-244.01\n",
+ "回合：170/400，奖励：-121.33\n",
+ "回合：180/400，奖励：-239.27\n",
+ "回合：190/400，奖励：-127.06\n",
+ "回合：200/400，奖励：-122.01\n",
+ "回合：210/400，奖励：-126.99\n",
+ "回合：220/400，奖励：-348.44\n",
+ "回合：230/400，奖励：-116.88\n",
+ "回合：240/400，奖励：-124.86\n",
+ "回合：250/400，奖励：-121.31\n",
+ "回合：260/400，奖励：-3.03\n",
+ "回合：270/400，奖励：-125.63\n",
+ "回合：280/400，奖励：-244.81\n",
+ "回合：290/400，奖励：-123.32\n",
+ "回合：300/400，奖励：-119.85\n",
+ "回合：310/400，奖励：-121.64\n",
+ "回合：320/400，奖励：-4.73\n",
+ "回合：330/400，奖励：-127.96\n",
+ "回合：340/400，奖励：-119.40\n",
+ "回合：350/400，奖励：-244.30\n",
+ "回合：360/400，奖励：-121.79\n",
+ "回合：370/400，奖励：-244.21\n",
+ "回合：380/400，奖励：-123.19\n",
+ "回合：390/400，奖励：-341.91\n",
+ "回合：400/400，奖励：-117.78\n",
+ "完成训练！\n",
+ "开始测试！\n",
+ "回合：1/10，奖励：-123.43\n",
+ "回合：2/10，奖励：-245.39\n",
+ "回合：3/10，奖励：-366.64\n",
+ "回合：4/10，奖励：-121.86\n",
+ "回合：5/10，奖励：-124.73\n",
+ "回合：6/10，奖励：-359.53\n",
+ "回合：7/10，奖励：-125.78\n",
+ "回合：8/10，奖励：-2.40\n",
+ "回合：9/10，奖励：-348.00\n",
+ "回合：10/10，奖励：-361.15\n",
+ "完成测试！\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "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'], title=f\"training curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\") \n",
+ "# 测试\n",
+ "res_dic = test(cfg, env, agent)\n",
+ "plot_rewards(res_dic['rewards'], title=f\"testing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\") # 画出结果"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "46214798",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "badea21e",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python (tensorflowenv)",
+ "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.6.5"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/pseudocodes/pseudo_without_notes.pdf b/pseudocodes/pseudo_without_notes.pdf
index 65dc956..1813b9b 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 c36afae..9692e71 100644
--- a/pseudocodes/pseudo_without_notes.tex
+++ b/pseudocodes/pseudo_without_notes.tex
@@ -323,7 +323,7 @@ \section{Advantage Actor Critic算法}
\section{PPO-Clip算法}
\begin{algorithm}[H] % [H]固定位置
- \floatname{algorithm}{{PPO-Clip算法}\footnotemark[1]\footnotemark[2]}
+ \floatname{algorithm}{{PPO-Clip算法}}
\renewcommand{\thealgorithm}{} % 去掉算法标号
\caption{}
\begin{algorithmic}[1] % [1]显示步数
@@ -332,12 +332,12 @@ \section{PPO-Clip算法}
\STATE 初始化epoch数$K$
\STATE 初始化经验回放$D$
\FOR {回合数 = $1,2,\cdots,M$}
- \STATE 根据策略$\pi_{\theta}$采样$C$个时步数据,收集轨迹$\tau = {s_0,a_0,r_1,...,s_t,a_t,r_{t+1},\cdots}$到经验回放$D$中
+ \STATE 使用策略$\pi_{\theta}$采样$C$个时步数据,收集轨迹$\tau = {s_0,a_0,r_1,...,s_t,a_t,r_{t+1},\cdots}$到经验回放$D$中
\FOR {epoch数 $ k = 1,2,\cdots,K$}
\STATE 计算折扣奖励$\hat{R_t}$
\STATE 计算优势函数，即$A^{\pi_{\theta_{k}}}=V_{\phi_k}-\hat{R_t}$
\STATE 结合重要性采样计算Actor损失，如下：
- \STATE $L^{CLIP}(\theta)= \frac{1}{|D_k|T}\sum_{\tau \in D_k}\sum_{t=0}^{T} min(\frac{\pi_\theta(a_t|s_t)}{\pi_{\theta_{k}}(a_t|s_t)} A^{\pi_{\theta_{k}}}(s_t,a_t), g(\epsilon,A^{\pi_{\theta_{k}}}(s_t,a_t)))$\footnotemark[3]
+ \STATE $L^{CLIP}(\theta)= \frac{1}{|D_k|T}\sum_{\tau \in D_k}\sum_{t=0}^{T} min(\frac{\pi_\theta(a_t|s_t)}{\pi_{\theta_{k}}(a_t|s_t)} A^{\pi_{\theta_{k}}}(s_t,a_t), g(\epsilon,A^{\pi_{\theta_{k}}}(s_t,a_t)))$
\STATE 梯度下降更新Actor参数：$\theta_{k+1} \leftarrow \theta_{k} + \alpha_{\theta} L^{CLIP}(\theta)$
\STATE 更新Critic参数:
\STATE $\phi_{k+1} \leftarrow \phi_{k}+ \alpha_{\phi}\frac{1}{|D_k|T}\sum_{\tau \in D_k}\sum_{t=0}^{T} (V_{\phi_{k}}(s_t)-\hat{R_t})^2$
@@ -345,9 +345,7 @@ \section{PPO-Clip算法}
\ENDFOR
\end{algorithmic}
\end{algorithm}
-\footnotetext[1]{Proximal Policy Optimization Algorithms}
-\footnotetext[2]{https://spinningup.openai.com/en/latest/algorithms/ppo.html}
-\footnotetext[3]{$L^{CLIP}(\theta)=\hat{E_t}[min(r_t(\theta)\hat{A_t}, clip(r_t(\theta), 1-\epsilon, 1+\epsilon)\hat{A_t})]$}
+
\clearpage
\section{PPO-KL散度算法}
@@ -449,7 +447,7 @@ \section{SoftQ算法}
\clearpage
\section{SAC-S算法}
\begin{algorithm}[H] % [H]固定位置
- \floatname{algorithm}{{SAC-S算法}\footnotemark[1]}
+ \floatname{algorithm}{{SAC-S算法}}
\renewcommand{\thealgorithm}{} % 去掉算法标号
\caption{}
\begin{algorithmic}[1] % [1]显示步数
@@ -473,7 +471,7 @@ \section{SAC-S算法}
\clearpage
\section{SAC算法}
\begin{algorithm}[H] % [H]固定位置
- \floatname{algorithm}{{SAC算法}\footnotemark[1]}
+ \floatname{algorithm}{{SAC算法}}
\renewcommand{\thealgorithm}{} % 去掉算法标号
\caption{}
\begin{algorithmic}[1]
@@ -488,19 +486,14 @@ \section{SAC算法}
\STATE 存储transition到经验回放中，$\mathcal{D} \leftarrow \mathcal{D} \cup\left\{\left(\mathbf{s}_{t}, \mathbf{a}_{t}, r\left(\mathbf{s}_{t}, \mathbf{a}_{t}\right), \mathbf{s}_{t+1}\right)\right\}$
\STATE 更新环境状态$s_{t+1} \leftarrow s_t$
\STATE {\bfseries 更新策略：}
- \STATE 更新$Q$函数，$\theta_{i} \leftarrow \theta_{i}-\lambda_{Q} \hat{\nabla}_{\theta_{i}} J_{Q}\left(\theta_{i}\right)$ for $i \in\{1,2\}$\footnotemark[2]\footnotemark[3]
- \STATE 更新策略权重，$\phi \leftarrow \phi-\lambda_{\pi} \hat{\nabla}_{\phi} J_{\pi}(\phi)$ \footnotemark[4]
- \STATE 调整temperature，$\alpha \leftarrow \alpha-\lambda \hat{\nabla}_{\alpha} J(\alpha)$ \footnotemark[5]
+ \STATE 更新$Q$函数，$\theta_{i} \leftarrow \theta_{i}-\lambda_{Q} \hat{\nabla}_{\theta_{i}} J_{Q}\left(\theta_{i}\right)$ for $i \in\{1,2\}$
+ \STATE 更新策略权重，$\phi \leftarrow \phi-\lambda_{\pi} \hat{\nabla}_{\phi} J_{\pi}(\phi)$
+ \STATE 调整温度因子，$\alpha \leftarrow \alpha-\lambda \hat{\nabla}_{\alpha} J(\alpha)$
\STATE 更新目标网络权重，$\bar{\theta}_{i} \leftarrow \tau \theta_{i}+(1-\tau) \bar{\theta}_{i}$ for $i \in\{1,2\}$
\ENDFOR
\ENDFOR
\end{algorithmic}
\end{algorithm}
-\footnotetext[2]{Soft Actor-Critic Algorithms and Applications}
-\footnotetext[2]{$J_{Q}(\theta)=\mathbb{E}_{\left(\mathbf{s}_{t}, \mathbf{a}_{t}\right) \sim \mathcal{D}}\left[\frac{1}{2}\left(Q_{\theta}\left(\mathbf{s}_{t}, \mathbf{a}_{t}\right)-\left(r\left(\mathbf{s}_{t}, \mathbf{a}_{t}\right)+\gamma \mathbb{E}_{\mathbf{s}_{t+1} \sim p}\left[V_{\bar{\theta}}\left(\mathbf{s}_{t+1}\right)\right]\right)\right)^{2}\right]$}
-% \footnotetext[3]{$\hat{\nabla}_{\theta} J_{Q}(\theta)=\nabla_{\theta} Q_{\theta}\left(\mathbf{a}_{t}, \mathbf{s}_{t}\right)\left(Q_{\theta}\left(\mathbf{s}_{t}, \mathbf{a}_{t}\right)-\left(r\left(\mathbf{s}_{t}), \mathbf{a}_{t}\right)+\gamma\left(Q_{\bar{\theta}}\left(\mathbf{s}_{t+1}, \mathbf{a}_{t+1}\right)-\alpha \log \left(\pi_{\phi}\left(\mathbf{a}_{t+1} \mid \mathbf{s}_{t+1}\right)\right)\right)\right)\right.$}
-% \footnotetext[4]{$\hat{\nabla}_{\phi} J_{\pi}(\phi)=\nabla_{\phi} \alpha \log \left(\pi_{\phi}\left(\mathbf{a}_{t} \mid \mathbf{s}_{t}\right)\right)+\left(\nabla_{\mathbf{a}_{t}} \alpha \log \left(\pi_{\phi}\left(\mathbf{a}_{t} \mid \mathbf{s}_{t}\right)\right)-\nabla_{\mathbf{a}_{t}} Q\left(\mathbf{s}_{t}, \mathbf{a}_{t}\right)\right) \nabla_{\phi} f_{\phi}\left(\epsilon_{t} ; \mathbf{s}_{t}\right)$,$\mathbf{a}_{t}=f_{\phi}\left(\epsilon_{t} ; \mathbf{s}_{t}\right)$}
-% \footnotetext[5]{$J(\alpha)=\mathbb{E}_{\mathbf{a}_{t} \sim \pi_{t}}\left[-\alpha \log \pi_{t}\left(\mathbf{a}_{t} \mid \mathbf{s}_{t}\right)-\alpha \overline{\mathcal{H}}\right]$}
\clearpage
@@ -529,7 +522,7 @@ \section{GAIL算法}
\section{MAPPO算法}
\begin{algorithm}[H] % [H]固定位置
- \floatname{algorithm}{{MAPPO算法}\footnotemark[1]\footnotemark[2]}
+ \floatname{algorithm}{{MAPPO算法}}
\renewcommand{\thealgorithm}{} % 去掉算法标号
\caption{}
\begin{algorithmic}[1] % [1]显示步数
@@ -539,7 +532,7 @@ \section{MAPPO算法}
\STATE 初始化经验回放$D$
\FOR {回合数 = $1,2,\cdots,M$}
\STATE 初始化状态$s_1$
- \STATE 每个智能体$u$都根据各自策略采样$C$个时步数据,收集轨迹$\tau^u = {\{o_t^u, a_t^u, r_{t+1}}\}_{t=1}^T$\footnotemark[3]
+ \STATE 每个智能体$u$都根据各自策略采样$C$个时步数据,收集轨迹$\tau^u = {\{o_t^u, a_t^u, r_{t+1}}\}_{t=1}^T$
\STATE 对每个时步的每条轨迹
\STATE 计算折扣奖励$\{\hat{R}_t^u\}_{t=1}^T$
\STATE 计算优势函数$\{A_t^u=V_{\phi_t}^u-\hat{R}_t^u\}_{t=1}^T$
@@ -550,7 +543,7 @@ \section{MAPPO算法}
\FOR {$j=0,1,\cdots,\frac{T}{B}-1$}
\STATE 选择$B$条数据$\{o_i^u, a_i^u, y_i^u, A_i^u\}_{i=1+Bj}^{B(j+1)}$
\STATE 计算梯度：
- \STATE $\bigtriangleup\theta^u=\frac{1}{B}\sum_{i=1}^B\{\bigtriangledown_{\theta^u}f(r_i(\theta^u),A_i^u)\}$\footnotetext[4]
+ \STATE $\bigtriangleup\theta^u=\frac{1}{B}\sum_{i=1}^B\{\bigtriangledown_{\theta^u}f(r_i(\theta^u),A_i^u)\}$
\STATE $\bigtriangleup\phi^u=\frac{1}{B}\sum_{i=1}^B\{\bigtriangledown_{\phi^u}(y_i^u-V_{\phi^u}(o_i^u))^2\}$
\STATE Adam梯度上升方法计算$\theta^u$，Adam梯度下降方法计算$\phi^u$
@@ -560,10 +553,6 @@ \section{MAPPO算法}
\ENDFOR
\end{algorithmic}
\end{algorithm}
-\footnotetext[1]{Joint Optimization of Handover Control and Power Allocation Based on Multi-Agent Deep Reinforcement Learning}
-\footnotetext[2]{The Surprising Effectiveness of PPO in Cooperative Multi-Agent Games}
-\footnotetext[3]{$o_t^u$是智能体$u$在时刻$t$的观测值，是局部观测值，而$s_t$是全局状态}
-\footnotetext[4]{函数f是目标函数，不同的方法如Clip或者KL散度等目标函数不同}
\clearpage
\end{document}
\ No newline at end of file