diff --git a/new/handson-rl-py/00.md b/new/handson-rl-py/00.md
index a6241887085d027466441ee1974ea849ca971600..dc239de021af020876dbc8d144ea274666b35a4f 100644
--- a/new/handson-rl-py/00.md
+++ b/new/handson-rl-py/00.md
@@ -12,7 +12,7 @@
 
 第 2 章和 “OpenAI 和 TensorFlow 入门”可帮助我们为各种强化学习任务设置机器。 我们将学习如何通过安装 Anaconda，Docker，OpenAI Gym，Universe 和 TensorFlow 来设置机器。 然后，我们将学习如何在 OpenAI Gym 中模拟代理，并且将了解如何构建视频游戏机器人。 我们还将学习 TensorFlow 的基础知识，并了解如何使用 TensorBoard 进行可视化。
 
-第 3 章，“马尔可夫决策过程和动态规划”首先说明什么是马尔可夫链和马尔可夫过程，然后我们将了解如何将强化学习问题建模为马尔可夫 决策过程。 我们还将学习一些基本概念，例如值函数，Q 函数和 Bellman 方程。 然后，我们将了解什么是动态规划以及如何使用价值和策略迭代来解决冻湖问题。
+第 3 章，“马尔可夫决策过程和动态规划”首先说明什么是马尔可夫链和马尔可夫过程，然后我们将了解如何将强化学习问题建模为马尔可夫 决策过程。 我们还将学习一些基本概念，例如值函数，Q 函数和贝尔曼方程。 然后，我们将了解什么是动态规划以及如何使用价值和策略迭代来解决冻湖问题。
 
 第 4 章，“使用蒙特卡洛方法进行的游戏”解释了蒙特卡洛方法和不同类型的蒙特卡洛预测方法，例如首次访问 MC 和每次访问 MC。 我们还将学习如何使用蒙特卡洛方法玩二十一点。 然后，我们将探讨不同的策略上和策略外的蒙特卡洛控制方法。
 
@@ -26,7 +26,7 @@
 
 第 9 章，“使用深度循环 Q 网络玩末日游戏”，介绍了深度循环 Q 网络（DRQN）及其与 DQN 的区别。 我们将看到如何构建使用 DRQN 播放 Doom 的代理。 在本章的后面，我们将学习深度注意力循环 Q 网络，该网络将注意力机制添加到 DRQN 架构中。
 
-第 10 章，“异步优势参与者批评者网络”解释了异步优势参与者批评者（A3C）网络的工作方式。 我们将详细探讨 A3C 架构，然后将学习如何构建使用 A3C 上山的代理。
+第 10 章，“异步优势演员评论家网络”解释了异步优势演员评论家（A3C）网络的工作方式。 我们将详细探讨 A3C 架构，然后将学习如何构建使用 A3C 上山的代理。
 
 第 11 章，“策略梯度和优化”涵盖了策略梯度如何帮助我们找到合适的策略而无需 Q 函数。 我们还将探索深度确定性策略梯度方法。 在本章的后面，我们将看到最新的策略优化方法，例如信任区域策略优化和近端策略优化。
 
@@ -56,9 +56,9 @@
 
 下载文件后，请确保使用以下最新版本解压缩或解压缩文件夹：
 
-*   Windows 的 WinRAR / 7-Zip
-*   Mac 版 Zipeg / iZip / UnRarX
-*   适用于 Linux 的 7-Zip / PeaZip
+*   Windows 的 WinRAR/7-Zip
+*   Mac 版 Zipeg/iZip/UnRarX
+*   适用于 Linux 的 7-Zip/PeaZip
 
 本书的代码包也托管在 [GitHub](https://github.com/PacktPublishing/Hands-On-Reinforcement-Learning-with-Python) 上。 如果代码有更新，它将在现有的 GitHub 存储库中进行更新。
 
diff --git a/new/handson-rl-py/01.md b/new/handson-rl-py/01.md
index ea6997149fca3e1a38d1ccf3cd59b14ce5cf1267..2f4baf8f42b22fbf65c39d4b9ee8044a804f36bb 100644
--- a/new/handson-rl-py/01.md
+++ b/new/handson-rl-py/01.md
@@ -13,7 +13,7 @@
 
 # 什么是 RL？
 
-考虑到您正在教狗接球，但是您不能明确地教狗接球； 取而代之的是，您将只扔一个球，每次狗抓到球时，您都将给它一个小甜饼。 如果无法接住球，则不会提供 cookie。 狗将找出使它收到 Cookie 的动作，然后重复这些动作。
+考虑到您正在教狗接球，但是您不能明确地教狗接球； 取而代之的是，您将只扔一个球，每次狗抓到球时，您都将给它一个曲奇。 如果无法接住球，则不会提供曲奇。 狗将找出使它收到 Cookie 的动作，然后重复这些动作。
 
 同样，在 RL 环境中，您不会教代理做什么或如何做，而是会针对代理执行的每个操作给予奖励。 奖励可以是正面的或负面的。 然后，代理将开始执行使其获得正面奖励的操作。 因此，这是一个反复试验的过程。 在先前的类比中，狗代表代理。 接球时给狗送饼干是一种积极的奖励，而不送饼干则是一种消极的奖励。
 
@@ -47,7 +47,7 @@ RL 代理可以**探索**可能提供良好奖励的不同动作，也可以**
 
 在监督学习中，机器（代理）从训练数据中学习，该训练数据具有一组标记的输入和输出。 目的是模型外推并概括其学习，以便可以很好地应用于看不见的数据。 有一个外部主管，他具有完整的环境知识基础并监督座席以完成一项任务。
 
-考虑一下我们刚才讨论的狗类比； 在监督学习中，要教狗接球，我们将通过指定向左转，向右走，前进五个步骤，接球等等来明确地教它。 但是在 RL 中，我们只是扔一个球，每当狗抓到球时，我们都会给它一个 cookie（奖励）。 因此，狗将学会接球，这意味着它收到了饼干。
+考虑一下我们刚才讨论的狗类比； 在监督学习中，要教狗接球，我们将通过指定向左转，向右走，前进五个步骤，接球等等来明确地教它。 但是在 RL 中，我们只是扔一个球，每当狗抓到球时，我们都会给它一个曲奇（奖励）。 因此，狗将学会接球，这意味着它收到了饼干。
 
 在无监督学习中，我们为模型提供只有一组输入的训练数据。 模型学习确定输入中的隐藏模式。 有一个普遍的误解，认为 RL 是一种无监督的学习，但事实并非如此。 在无监督学习中，模型学习隐藏的结构，而在 RL 中，模型通过最大化奖励来学习。 假设我们想向用户推荐新电影。 无监督学习会分析用户观看过的相似电影并建议电影，而 RL 会不断从用户那里收到反馈，了解他的电影偏好，并在此基础上建立知识库并建议新电影。
 
@@ -142,7 +142,7 @@ OpenAI Universe 是 OpenAI Gym 的扩展。 它提供了在各种简单到实时
 
 DeepMind Lab 是另一个基于 AI 代理的惊人研究平台。 它提供了一个丰富的模拟环境，可以作为运行几种 RL 算法的实验室。 它是高度可定制和可扩展的。 视觉效果非常丰富，科幻风格且逼真。
 
-# RL 胶
+# RLGlue
 
 RL-Glue 提供了一个接口，用于将代理，环境和程序连接在一起，即使它们是用不同的编程语言编写的。 它具有与他人共享您的代理和环境以在您的工作之上进行构建的能力。 由于这种兼容性，可重用性大大提高了。
 
@@ -152,7 +152,7 @@ RL-Glue 提供了一个接口，用于将代理，环境和程序连接在一起
 
 # ViZDoom
 
-顾名思义，ViZDoom 是一个基于厄运的 AI 平台。 它为多代理提供支持，并提供竞争环境来测试代理。 但是，ViZDoom 仅支持 Doom 游戏环境。 它提供了屏幕外渲染以及单人和多人游戏支持。
+顾名思义，ViZDoom 是一个基于Doom的 AI 平台。 它为多代理提供支持，并提供竞争环境来测试代理。 但是，ViZDoom 仅支持 Doom 游戏环境。 它提供了屏幕外渲染以及单人和多人游戏支持。
 
 # RL 的应用
 
@@ -186,7 +186,7 @@ RL 被广泛用于金融投资组合管理，这是将资金不断重新分配
 
 在本章中，我们学习了 RL 的基础知识以及一些关键概念。 我们了解了 RL 的不同元素和 RL 环境的不同类型。 我们还介绍了各种可用的 RL 平台以及 RL 在各个领域中的应用。
 
-在下一章[，第 2 章](02.html#1LCVG0-3c5bb317ad314d43ac43a332c0db6f00)， “OpenAI 和 TensorFlow” 入门中，我们将学习 OpenAI 和 TensorFlow 的基础知识以及如何安装 OpenAI 和 TensorFlow，然后模拟环境并教给代理如何 在环境中学习。
+在下一章第 2 章， “OpenAI 和 TensorFlow” 入门中，我们将学习 OpenAI 和 TensorFlow 的基础知识以及如何安装 OpenAI 和 TensorFlow，然后模拟环境并教给代理如何 在环境中学习。
 
 # 问题
 
diff --git a/new/handson-rl-py/02.md b/new/handson-rl-py/02.md
index af191c8613473110ebce583ebcbd4c8cd1b6ab08..a435177f84e6fd4c2e2f39c16c38385e8c34e292 100644
--- a/new/handson-rl-py/02.md
+++ b/new/handson-rl-py/02.md
@@ -51,9 +51,9 @@ source activate universe
 
 # 安装 Docker
 
-安装 Anaconda 之后，我们需要安装 Docker。 Docker 使将应用程序部署到生产变得容易。 假设您在具有 TensorFlow 和其他一些库的 localhost 中构建了一个应用程序，并且要将应用程序部署到服务器中。 您将需要在服务器上安装所有这些依赖项。 但是使用 Docker，我们可以将应用程序及其依赖项打包在一起，这称为容器，并且我们可以在服务器上运行应用程序而无需在打包的 Docker 容器中使用任何外部依赖项。 OpenAI 不支持 Windows，因此要在 Windows 中安装 OpenAI，我们需要使用 Docker。 而且，大多数 OpenAI Universe 环境都需要 Docker 来模拟环境。 现在让我们看看如何安装 Docker。
+安装 Anaconda 之后，我们需要安装 Docker。 Docker 使将应用程序部署到生产变得容易。 假设您在具有 TensorFlow 和其他一些库的`localhost`中构建了一个应用程序，并且要将应用程序部署到服务器中。 您将需要在服务器上安装所有这些依赖项。 但是使用 Docker，我们可以将应用程序及其依赖项打包在一起，这称为容器，并且我们可以在服务器上运行应用程序而无需在打包的 Docker 容器中使用任何外部依赖项。 OpenAI 不支持 Windows，因此要在 Windows 中安装 OpenAI，我们需要使用 Docker。 而且，大多数 OpenAI Universe 环境都需要 Docker 来模拟环境。 现在让我们看看如何安装 Docker。
 
-要下载 Docker，请转至[这里](https://docs.docker.com/)，您将在其中看到一个名为 Get Docker 的选项。 如果选择该选项，则将看到不同操作系统的选项。 如果使用 Windows 或 Mac，则可以下载 Docker 并直接使用图形安装程序进行安装。
+要下载 Docker，请转至[这里](https://docs.docker.com/)，您将在其中看到一个名为“Get Docker”的选项。 如果选择该选项，则将看到不同操作系统的选项。 如果使用 Windows 或 Mac，则可以下载 Docker 并直接使用图形安装程序进行安装。
 
 如果您使用的是 Linux，请按照以下步骤操作：
 
@@ -281,7 +281,7 @@ for _ in range(1000):
 
 现在，让我们学习如何使用 Gym 训练机器人走路以及一些基础知识。
 
-该策略是当机器人向前移动时将获得 X 点作为奖励，如果机器人无法移动，则会减少 Y 点。 因此，机器人将在最大化奖励的情况下学习行走。
+该策略是当机器人向前移动时将获得`X`点作为奖励，如果机器人无法移动，则会减少`Y`点。 因此，机器人将在最大化奖励的情况下学习行走。
 
 首先，我们将导入库，然后通过`make`函数创建一个仿真实例。 Open AI Gym 提供了一个称为`BipedalWalker-v2`的环境，用于在简单的地形中训练机器人特工：
 
@@ -326,7 +326,7 @@ observation, reward, done, info = env.step(action)
 
 `info`是可用于调试的信息。
 
-当`done`为 true 时，我们打印该情节采取的时间步长并中断当前情节：
+当`done`为`true`时，我们打印该情节采取的时间步长并中断当前情节：
 
 ```py
 if done:
@@ -530,7 +530,7 @@ while True:
 
 # TensorFlow
 
-TensorFlow 是 Google 的开源软件库，已广泛用于数值计算。 它被广泛用于构建深度学习模型，并且是机器学习的一个子集。 它使用可以在许多不同平台上共享和执行的数据流图。 Tensor 只是多维数组，因此，当我们说 TensorFlow 时，它实际上是计算图中的多维数组（张量）的流。
+TensorFlow 是 Google 的开源软件库，已广泛用于数值计算。 它被广泛用于构建深度学习模型，并且是机器学习的一个子集。 它使用可以在许多不同平台上共享和执行的数据流图。 张量只是多维数组，因此，当我们说 TensorFlow 时，它实际上是计算图中的多维数组（张量）的流。
 
 安装 Anaconda 后，安装 TensorFlow 变得非常简单。 无论使用什么平台，都可以通过键入以下命令轻松安装 TensorFlow：
 
@@ -750,7 +750,7 @@ with tf.Session() as sess:
 
 在本章中，我们学习了如何通过安装 Anaconda，Docker，OpenAI Gym，Universe 和 TensorFlow 来设置机器。 我们还学习了如何使用 OpenAI 创建模拟，以及如何训练代理在 OpenAI 环境中学习。 然后，我们了解了 TensorFlow 的基础知识，然后在 TensorBoard 中可视化了图形。
 
-在下一章[，第 3 章](03.html#2BASE0-3c5bb317ad314d43ac43a332c0db6f00)，“马尔可夫决策过程和动态规划”中，我们将学习马尔可夫决策过程和动态规划以及如何使用价值和策略迭代来解决冻湖问题。
+在下一章第 3 章，“马尔可夫决策过程和动态规划”中，我们将学习马尔可夫决策过程和动态规划以及如何使用价值和策略迭代来解决冻湖问题。
 
 # 问题
 
diff --git a/new/handson-rl-py/03.md b/new/handson-rl-py/03.md
index 65ca59a1e0f52311005fca0c00cf09f0e230d3c5..45f69116079735e5c3800cd2a26b570f884846d1 100644
--- a/new/handson-rl-py/03.md
+++ b/new/handson-rl-py/03.md
@@ -8,7 +8,7 @@
 *   马尔可夫决策过程
 *   奖励与退货
 *   贝尔曼方程
-*   使用动态规划求解 Bellman 方程
+*   使用动态规划求解贝尔曼方程
 *   利用价值和策略迭代来解决冻湖问题
 
 # 马尔可夫链与马尔可夫过程
@@ -17,7 +17,7 @@
 
 马尔可夫性质指出，未来仅取决于现在而不是过去。 马尔可夫链是一个概率模型，仅依靠当前状态来预测下一个状态，而不是先前的状态，也就是说，未来有条件地独立于过去。 马尔可夫链严格遵循马尔可夫属性。
 
-例如，如果我们知道当前状态是多云，则可以预测下一个状态可能是雨天。 我们得出的结论是，只有考虑当前状态（多云）而不考虑过去的状态（可能是晴天，大风等），下一个状态才会下雨。 但是，Markov 属性并不适用于所有进程。 例如，掷骰子（下一个状态）与前一个数字无关，无论骰子上显示的是什么（当前状态）。
+例如，如果我们知道当前状态是多云，则可以预测下一个状态可能是雨天。 我们得出的结论是，只有考虑当前状态（多云）而不考虑过去的状态（可能是晴天，大风等），下一个状态才会下雨。 但是，马尔可夫属性并不适用于所有进程。 例如，掷骰子（下一个状态）与前一个数字无关，无论骰子上显示的是什么（当前状态）。
 
 从一种状态移动到另一种状态称为**转移**，其概率称为**转移概率**。 我们可以用表格的形式来表示转移概率，如下所示，它被称为**马尔可夫表**。 在给定当前状态的情况下，它显示了移至下一个状态的概率为：
 
@@ -53,7 +53,7 @@
 
 ![](img/00019.jpeg)
 
-马尔可夫链位于核心概念中，即未来仅取决于现在而不是过去。 如果遵循 Markov 属性，则随机过程称为 Markov 过程。
+马尔可夫链位于核心概念中，即未来仅取决于现在而不是过去。 如果遵循马尔可夫属性，则随机过程称为马尔可夫过程。
 
 # 马尔可夫决策过程
 
@@ -69,7 +69,7 @@ MDP 由五个重要元素表示：
 
 # 奖励与退货
 
-如我们所知，在 RL 环境中，代理通过执行操作与环境交互，并从一种状态转移到另一种状态。 根据其执行的动作，它会获得奖励。 奖励不过是一个数字值，例如，一个好动作为+1，而一个坏动作为-1。 我们如何确定一个动作是好是坏？ 在迷宫游戏中，好动作是指特工进行移动以使其不会撞到迷宫壁的地方，而不好的动作是指特工进行移动并撞到迷宫壁的地方。
+如我们所知，在 RL 环境中，代理通过执行操作与环境交互，并从一种状态转移到另一种状态。 根据其执行的动作，它会获得奖励。 奖励不过是一个数字值，例如，一个好动作为 +1，而一个坏动作为 -1。 我们如何确定一个动作是好是坏？ 在迷宫游戏中，好动作是指特工进行移动以使其不会撞到迷宫壁的地方，而不好的动作是指特工进行移动并撞到迷宫壁的地方。
 
 代理试图最大化从环境而不是即时奖励中获得的奖励（累积奖励）总量。 代理商从环境中获得的总奖励金额称为回报。 因此，我们可以将代理商收到的奖励（回报）总额计算如下：
 
@@ -119,7 +119,7 @@ MDP 由五个重要元素表示：
 
 ![](img/00043.jpeg)
 
-这根据策略`π`指定从状态`s`开始的预期收益。 我们可以用（2）的值函数替换`R[t]`的值，如下所示：
+这根据策略`π`指定从状态`s`开始的预期收益。 我们可以用`(2)`的值函数替换`R[t]`的值，如下所示：
 
 ![](img/00044.jpeg)
 
@@ -159,7 +159,7 @@ MDP 由五个重要元素表示：
 
 每当我们说值函数`V(S)`或`Q`函数`Q(S, a)`时，它实际上表示值表，而`Q`表，如前所示。
 
-# Bellman 方程和最优性
+#贝尔曼方程和最优性
 
 以美国数学家理查德·贝尔曼（Richard Bellman）命名的贝尔曼方程式可帮助我们求解 MDP。 它在 RL 中无处不在。 当我们说解决 MDP 时，实际上意味着找到最佳的策略和价值功能。 根据不同的策略，可以有许多不同的价值函数。 与所有其他值函数相比，最优值函数![](img/00047.jpeg)是产生最大值的函数：
 
@@ -169,27 +169,27 @@ MDP 由五个重要元素表示：
 
 由于最优值函数![](img/00049.jpeg)是比所有其他值函数（即最大收益）更高的值的函数，因此它将是`Q`函数的最大值。 因此，可以通过将`Q`函数的最大值取如下来轻松地计算最佳值函数：
 
-![](img/00050.jpeg)-（3）
+![](img/00050.jpeg) ---（3）
 
-值函数的 Bellman 方程可以表示为（在下一主题中，我们将看到如何推导该方程）：
+值函数的贝尔曼方程可以表示为（在下一主题中，我们将看到如何推导该方程）：
 
 ![](img/00051.jpeg)
 
 它指示状态值及其后继状态与所有可能性的平均值之间的递归关系。
 
-类似地，用于`Q`函数的 Bellman 方程可以表示为：
+类似地，用于`Q`函数的贝尔曼方程可以表示为：
 
 ![](img/00052.jpeg) ---（4）
 
-将公式（4）代入（3），我们得到：
+将公式`(4)`代入`(3)`，我们得到：
 
 ![](img/00053.jpeg)
 
-前面的方程式称为 Bellman 最优方程式。 在接下来的部分中，我们将看到如何通过求解该方程式找到最佳策略。
+前面的方程式称为贝尔曼最优方程式。 在接下来的部分中，我们将看到如何通过求解该方程式找到最佳策略。
 
-# 推导值和 Q 函数的 Bellman 方程
+# 推导值和 Q 函数的贝尔曼方程
 
-现在，让我们看看如何导出值和`Q`函数的 Bellman 方程。
+现在，让我们看看如何导出值和`Q`函数的贝尔曼方程。
 
 如果您对数学不感兴趣，可以跳过本节。 但是，数学将非常有趣。
 
@@ -201,13 +201,13 @@ MDP 由五个重要元素表示：
 
 ![](img/00061.jpeg)
 
-![](img/00062.jpeg) from（2）---（5）
+![](img/00062.jpeg) 来自（2）---（5）
 
 我们知道值函数可以表示为：
 
 ![](img/00063.jpeg)
 
-![](img/00064.jpeg)来自（1）
+![](img/00064.jpeg) 来自（1）
 
 我们可以通过获取第一笔报酬来重写价值函数：
 
@@ -219,11 +219,11 @@ MDP 由五个重要元素表示：
 
 ![](img/00066.jpeg)
 
-在 RHS 中，我们将等式（5）中的![](img/00067.jpeg)替换为：
+在 RHS 中，我们将等式`(5)`中的![](img/00067.jpeg)替换为：
 
 ![](img/00068.jpeg)
 
-同样，在 LHS 中，我们将从等式（2）中替换`r[t + 1]`的值，如下所示：
+同样，在 LHS 中，我们将从等式`(2)`中替换`r[t + 1]`的值，如下所示：
 
 ![](img/00069.jpeg)
 
@@ -231,29 +231,29 @@ MDP 由五个重要元素表示：
 
 ![](img/00070.jpeg) ---（7）
 
-现在，我们将期望值（7）替换为值函数（6），如下所示：
+现在，我们将期望值`(7)`替换为值函数`(6)`，如下所示：
 
 ![](img/00071.jpeg)
 
-代替![](img/00072.jpeg)，我们可以用等式（6）代替![](img/00073.jpeg)，我们的最终值函数如下所示：
+代替![](img/00072.jpeg)，我们可以用等式`(6)`代替![](img/00073.jpeg)，我们的最终值函数如下所示：
 
 ![](img/00074.jpeg)
 
-以非常相似的方式，我们可以为`Q`函数导出一个 Bellman 方程； 最终方程如下：
+以非常相似的方式，我们可以为`Q`函数导出一个贝尔曼方程； 最终方程如下：
 
 ![](img/00075.jpeg)
 
-现在，对于值函数和`Q`函数都有一个 Bellman 方程，我们将看到如何找到最佳策略。
+现在，对于值函数和`Q`函数都有一个贝尔曼方程，我们将看到如何找到最佳策略。
 
-# 求解 Bellman 方程
+# 求解贝尔曼方程
 
-我们可以通过求解 Bellman 最优性方程来找到最优策略。 为了解决 Bellman 最优性方程，我们使用一种称为动态规划的特殊技术。
+我们可以通过求解贝尔曼最优性方程来找到最优策略。 为了解决贝尔曼最优性方程，我们使用一种称为动态规划的特殊技术。
 
 # 动态规划
 
 **动态规划**（**DP**）是一种解决复杂问题的技术。 在 DP 中，不是一次解决一个复杂的问题，而是将问题分解为简单的子问题，然后针对每个子问题，我们计算并存储解决方案。 如果出现相同的子问题，我们将不会重新计算，而是使用已经计算的解决方案。 因此，DP 有助于极大地减少计算时间。 它的应用广泛，包括计算机科学，数学，生物信息学等。
 
-我们使用两种强大的算法来求解 Bellman 方程：
+我们使用两种强大的算法来求解贝尔曼方程：
 
 *   价值迭代
 *   策略迭代
@@ -269,11 +269,11 @@ MDP 由五个重要元素表示：
 1.  首先，我们初始化随机值函数，即每个状态的随机值。
 2.  然后，我们为`Q(s, a)`的所有状态动作对计算`Q`函数。
 3.  然后，我们使用`Q(s, a)`中的最大值更新值函数。
-4.  我们重复这些步骤，直到 value 函数的变化很小。
+4.  我们重复这些步骤，直到值函数的变化很小。
 
 让我们通过手动逐步执行值迭代来直观地理解它。
 
-考虑此处显示的网格。 让我们说我们处于状态`A`，我们的目标是在不访问状态`B`的情况下达到状态`C`，我们有两个动作，0-左/右 和 1-上/下：
+考虑此处显示的网格。 让我们说我们处于状态`A`，我们的目标是在不访问状态`B`的情况下达到状态`C`，我们有两个动作，0 -- 左/右 和 1 -- 上/下：
 
 ![](img/00077.gif)
 
@@ -430,7 +430,7 @@ policy_iteration():
 *`H`是孔，您必须非常小心
 *`G`是目标（办公室）
 
-好的，现在让我们代替您使用我们的代理来找到到达办公室的正确方法。 该代理的目标是找到从`S`到`G`的最佳路径，而不会陷入`H`的陷阱。 代理商如何做到这一点？ 如果代理正确地在冰冻的湖面上行走，我们给+1 分作为奖励，如果代理正确落入洞中，则给 0 分，以便代理确定正确的行动。 代理现在将尝试找到最佳策略。 最优策略意味着采取正确的道路，这将最大化代理商的报酬。 如果代理人正在使报酬最大化，则显然代理人正在学习跳过漏洞并到达目的地。
+好的，现在让我们代替您使用我们的代理来找到到达办公室的正确方法。 该代理的目标是找到从`S`到`G`的最佳路径，而不会陷入`H`的陷阱。 代理商如何做到这一点？ 如果代理正确地在冰冻的湖面上行走，我们给 +1 分作为奖励，如果代理正确落入洞中，则给 0 分，以便代理确定正确的行动。 代理现在将尝试找到最佳策略。 最优策略意味着采取正确的道路，这将最大化代理商的报酬。 如果代理人正在使报酬最大化，则显然代理人正在学习跳过漏洞并到达目的地。
 
 我们可以将问题建模为我们先前研究的 MDP。 MDP 包含以下内容：
 
@@ -447,16 +447,16 @@ policy_iteration():
 
 当我们说有多好时，这到底意味着什么？ 这意味着最大化奖励是多么的好。
 
-然后，我们使用称为 Bellman 最优性方程的特殊方程式表示值函数和`Q`函数。 如果我们解决这个方程，我们可以找到最佳策略。 在这里，求解方程式意味着找到正确的价值函数和策略。 如果我们找到正确的价值功能和策略，那将是我们获得最大回报的最佳途径。
+然后，我们使用称为贝尔曼最优性方程的特殊方程式表示值函数和`Q`函数。 如果我们解决这个方程，我们可以找到最佳策略。 在这里，求解方程式意味着找到正确的价值函数和策略。 如果我们找到正确的价值功能和策略，那将是我们获得最大回报的最佳途径。
 
-我们将使用一种称为动态规划的特殊技术来求解 Bellman 最优性方程。 要应用 DP，必须预先知道模型动力学，这基本上意味着必须预先知道模型环境的转换概率和奖励概率。 由于我们知道模型动力学，因此可以在此处使用 DP。 我们使用两种特殊的 DP 算法来找到最佳策略：
+我们将使用一种称为动态规划的特殊技术来求解贝尔曼最优性方程。 要应用 DP，必须预先知道模型动力学，这基本上意味着必须预先知道模型环境的转换概率和奖励概率。 由于我们知道模型动力学，因此可以在此处使用 DP。 我们使用两种特殊的 DP 算法来找到最佳策略：
 
 *   价值迭代
 *   策略迭代
 
 # 价值迭代
 
-简单来说，在值迭代中，我们首先将一些随机值初始化为 value 函数。 我们初始化的随机值很有可能不会达到最佳状态。 因此，我们遍历每个状态并找到新的值函数； 我们停止迭代，直到找到最佳值函数。 一旦找到最优值函数，就可以轻松地从中提取最优策略。
+简单来说，在值迭代中，我们首先将一些随机值初始化为值函数。 我们初始化的随机值很有可能不会达到最佳状态。 因此，我们遍历每个状态并找到新的值函数； 我们停止迭代，直到找到最佳值函数。 一旦找到最优值函数，就可以轻松地从中提取最优策略。
 
 现在我们将看到如何使用值迭代来解决冻湖问题。
 
@@ -475,7 +475,7 @@ env = gym.make('FrozenLake-v0')
 
 我们将首先探索环境。
 
-由于我们有一个 4 * 4 的网格，因此环境中的状态数为 16：
+由于我们有一个`4 * 4`的网格，因此环境中的状态数为 16：
 
 ```py
 print(env.observation_space.n)
@@ -845,7 +845,7 @@ print (policy_iteration(env))
 
 # 概要
 
-在本章中，我们了解了什么是马尔可夫链和马尔可夫过程，以及如何使用 MDP 表示 RL 问题。 我们还研究了 Bellman 方程，并解决了 Bellman 方程，从而使用 DP 推导了最优策略。 在下一章第 4 章，“使用蒙特卡洛方法进行游戏”中，我们将研究蒙特卡洛树搜索以及如何使用它进行智能游戏的构建。
+在本章中，我们了解了什么是马尔可夫链和马尔可夫过程，以及如何使用 MDP 表示 RL 问题。 我们还研究了贝尔曼方程，并解决了贝尔曼方程，从而使用 DP 推导了最优策略。 在下一章第 4 章，“使用蒙特卡洛方法进行游戏”中，我们将研究蒙特卡洛树搜索以及如何使用它进行智能游戏的构建。
 
 # 问题
 
@@ -855,8 +855,8 @@ print (policy_iteration(env))
 2.  为什么我们需要马尔可夫决策过程？
 3.  我们何时更喜欢即时奖励？
 4.  折扣因子有什么用？
-5.  为什么要使用 Bellman 函数？
-6.  您将如何导出 Q 函数的 Bellman 方程？
+5.  为什么要使用贝尔曼函数？
+6.  您将如何导出 Q 函数的贝尔曼方程？
 7.  值函数和 Q 函数有何关系？
 8.  价值迭代和策略迭代有什么区别？
 
diff --git a/new/handson-rl-py/04.md b/new/handson-rl-py/04.md
index d662e7935983e974e8c59c0708c4d66ff88f9c23..843f95065054c8156de56637c45779122e0fd516 100644
--- a/new/handson-rl-py/04.md
+++ b/new/handson-rl-py/04.md
@@ -1,6 +1,6 @@
 # 蒙特卡洛方法进行游戏
 
-蒙特卡洛算法是从物理，机械到计算机科学的各个领域中最受欢迎和最常用的算法之一。 当未知环境模型时，在**强化学习**（**RL**）中使用 Monte Carlo 算法。 在上一章第 3 章，“马尔可夫决策过程和动态规划”中，我们着眼于使用**动态规划**（**DP**）查找 我们了解模型动态的最佳策略，即转移和奖励概率。 但是，当我们不知道模型动态时，如何确定最佳策略？ 在这种情况下，我们使用蒙特卡洛算法； 当我们不了解环境时，它对于找到最佳策略非常有用。
+蒙特卡洛算法是从物理，机械到计算机科学的各个领域中最受欢迎和最常用的算法之一。 当未知环境模型时，在**强化学习**（**RL**）中使用蒙特卡洛算法。 在上一章第 3 章，“马尔可夫决策过程和动态规划”中，我们着眼于使用**动态规划**（**DP**）查找 我们了解模型动态的最佳策略，即转移和奖励概率。 但是，当我们不知道模型动态时，如何确定最佳策略？ 在这种情况下，我们使用蒙特卡洛算法； 当我们不了解环境时，它对于找到最佳策略非常有用。
 
 在本章中，您将了解以下内容：
 
@@ -18,7 +18,7 @@
 
 **有趣的事实**：蒙特卡洛以斯坦尼斯瓦夫·乌兰的叔叔的名字命名，他经常从亲戚那里借钱在蒙特卡洛赌场赌博。
 
-# 使用蒙特卡洛估算 pi 的值
+# 使用蒙特卡洛估算`pi`的值
 
 想象一下，将一个圆的象限放置在正方形内，如下所示，然后我们在正方形内生成一些随机点。 您会看到一些点落在圆内，而另一些点在圆外：
 
@@ -161,7 +161,7 @@ print("Approximate value of pi is {}" .format(calculate_pi(points_inside_circle,
 
 # 蒙特卡洛预测
 
-在 DP 中，我们通过使用值迭代和策略迭代来解决**马尔可夫决策过程**（**MDP**）。 这两种技术都需要转换和奖励概率才能找到最佳策略。 但是，当我们不知道转移和奖励概率时，如何解决 MDP？ 在这种情况下，我们使用蒙特卡洛方法。 蒙特卡洛方法仅需要状态，动作和奖励的样本序列。 蒙特卡罗方法仅适用于情节任务。 由于 Monte Carlo 不需要任何模型，因此称为无模型学习算法。
+在 DP 中，我们通过使用值迭代和策略迭代来解决**马尔可夫决策过程**（**MDP**）。 这两种技术都需要转换和奖励概率才能找到最佳策略。 但是，当我们不知道转移和奖励概率时，如何解决 MDP？ 在这种情况下，我们使用蒙特卡洛方法。 蒙特卡洛方法仅需要状态，动作和奖励的样本序列。 蒙特卡罗方法仅适用于情节任务。 由于蒙特卡洛不需要任何模型，因此称为无模型学习算法。
 
 蒙特卡洛方法的基本思想非常简单。 您还记得我们在上一章第 3 章，“马尔可夫决策过程和动态规划”中如何定义最佳值函数以及如何得出最佳策略吗？
 
@@ -172,7 +172,7 @@ print("Approximate value of pi is {}" .format(calculate_pi(points_inside_circle,
 使用蒙特卡洛预测，我们可以估计任何给定策略的价值函数。 蒙特卡洛预测中涉及的步骤非常简单，如下所示：
 
 1.  首先，我们将随机值初始化为我们的值函数
-2.  然后我们初始化一个称为 return 的空列表来存储我们的退货
+2.  然后我们初始化一个称为`return`的空列表来存储我们的退货
 3.  然后针对情节中的每个州，我们计算收益
 4.  接下来，我们将退货附加到退货清单中
 5.  最后，我们将收益平均值作为我们的价值函数
@@ -205,22 +205,22 @@ print("Approximate value of pi is {}" .format(calculate_pi(points_inside_circle,
 *   最初，给玩家一张两张牌。 这两个卡都面朝上，即对其他人可见。
 *   庄家也得到了两张牌。 一张卡面朝上，另一张面朝下。 也就是说，发牌人只显示他的一张牌。
 
-*   如果在收到两张牌后，一张牌的总和为 21（例如，一位牌手已收到 10 + 11 = 21 的杰克和王牌），则称其为**自然**或**黑杰克**，玩家获胜。
+*   如果在收到两张牌后，一张牌的总和为 21（例如，一位牌手已收到`10 + 11 = 21`的杰克和王牌），则称其为**自然**或**黑杰克**，玩家获胜。
 *   如果发牌人在收到两张卡后立即的总卡数也为 21，则称为**两可**（Draw），因为它们两张都有 21 张。
 *   在每个回合中，玩家决定是否需要另一张纸牌来总计接近 21 张纸牌。
 *   如果玩家需要纸牌，则称其为**拿牌**（Hit）。
 *   如果玩家不需要纸牌，则称为**停牌**（Stand）。
 *   如果玩家的纸牌总数超过 21，则称为**胀死**（Bust）； 那么发牌者将赢得比赛。
 
-让我们通过玩来更好地了解二十一点。 我让你成为玩家，我是经销商：
+让我们通过玩来更好地了解二十一点。 我让你成为玩家，我是智能体：
 
 ![](img/00099.jpeg)
 
-在上图中，我们有一个参与者和一个庄家。 他们两个都有两张卡。 玩家的两张牌都朝上（可见），而发牌者的一张牌朝上（可见），另一张牌朝下（不可见）。 在第一轮中，您得到了两张卡，例如一个千斤顶和一个数字 7，即（10 + 7 = 17），而我作为发牌人只会向您显示一张数字 2。 面朝下。 现在，您必须决定要击中（需要另一张牌）还是站起来（不需要另一张牌）。 如果您选择击中并接收数字 3，您将获得 10 + 7 + 3 = 20（接近 21），您将获胜：
+在上图中，我们有一个参与者和一个庄家。 他们两个都有两张卡。 玩家的两张牌都朝上（可见），而发牌者的一张牌朝上（可见），另一张牌朝下（不可见）。 在第一轮中，您得到了两张卡，例如一个千斤顶和一个数字 7，即（`10 + 7 = 17`），而我作为发牌人只会向您显示一张数字 2。 面朝下。 现在，您必须决定要击中（需要另一张牌）还是站起来（不需要另一张牌）。 如果您选择击中并接收数字 3，您将获得`10 + 7 + 3 = 20`（接近 21），您将获胜：
 
 ![](img/00100.jpeg)
 
-但是，如果您收到一张卡，说出数字 7，则 10 + 7 + 7 = 24，超过了 21。然后被称为破产，您输了游戏。 如果您决定站立使用初始卡，则只有 10 + 7 =17。然后我们将检查经销商的卡总和。 如果它大于 17 且不超过 21，则经销商赢，否则您赢：
+但是，如果您收到一张卡，说出数字 7，则`10 + 7 + 7 = 24`，超过了 21。然后被称为破产，您输了游戏。 如果您决定站立使用初始卡，则只有`10 + 7 = 17`。然后我们将检查智能体的卡总和。 如果它大于 17 且不超过 21，则智能体赢，否则您赢：
 
 ![](img/00101.jpeg)
 
@@ -235,7 +235,7 @@ print("Approximate value of pi is {}" .format(calculate_pi(points_inside_circle,
 *   **拿牌**：如果玩家需要纸牌
 *   **停牌**：如果玩家不需要纸牌
 
-玩家必须决定一张王牌的价值。 如果玩家的纸牌总数为 10，并且在击中后获得一张王牌，则可以将其视为 11，而 10 + 11 =21。但是，如果玩家的纸牌总数为 15，并且在击中后，则获得一张王牌。 ，如果他将其视为 11 且 15 + 11 = 26，则表示破产。 如果玩家拥有一张王牌，我们可以将其称为**可用王牌**； 玩家可以将其视为 11，而不会破产。 如果玩家通过将 ace 视为 11 来破产，则称为**不可用王牌**。
+玩家必须决定一张王牌的价值。 如果玩家的纸牌总数为 10，并且在击中后获得一张王牌，则可以将其视为 11，而`10 + 11 = 21`。但是，如果玩家的纸牌总数为 15，并且在击中后，则获得一张王牌。 ，如果他将其视为 11 且`15 + 11 = 26`，则表示破产。 如果玩家拥有一张王牌，我们可以将其称为**可用王牌**； 玩家可以将其视为 11，而不会破产。 如果玩家通过将王牌视为 11 来破产，则称为**不可用王牌**。
 
 现在，我们将看到如何使用首次访问的蒙特卡洛算法来实现二十一点。
 
@@ -535,13 +535,13 @@ MC-ES 算法非常简单，如下所示：
 | 状态 1 | 动作 1 | 0.1 |
 | 状态 1 | 动作 2 | 0.8 |
 
-如果我们表现出贪婪的态度，那么我们将从所有探索的动作中挑选出具有最大价值的动作。 在前面的情况中，我们具有较高价值的动作 2，因此我们选择该动作。 但是状态 1 中可能还有其他我们尚未探讨的动作，可能价值最高。 因此，我们必须在所有探索的动作中寻找最佳动作或利用最佳动作。 这就是所谓的勘探开发困境。 假设您听过爱德·希兰（Ed Sheeran），并且非常喜欢他，所以您因为喜欢音乐而一直只听（探索）爱德·希兰（Ed Sheeran）。 但是，如果您尝试听其他艺术家的音乐，您可能会喜欢比 Ed Sheeran（探索）更好的人。 关于您是否只需要听 Ed Sheeran（开发）还是尝试听不同的艺术家以查看您是否喜欢他们（开发）的这种困惑称为探索开发难题。
+如果我们表现出贪婪的态度，那么我们将从所有探索的动作中挑选出具有最大价值的动作。 在前面的情况中，我们具有较高价值的动作 2，因此我们选择该动作。 但是状态 1 中可能还有其他我们尚未探讨的动作，可能价值最高。 因此，我们必须在所有探索的动作中寻找最佳动作或利用最佳动作。 这就是所谓的探索利用困境。 假设您听过爱德·希兰（Ed Sheeran），并且非常喜欢他，所以您因为喜欢音乐而一直只听（探索）爱德·希兰（Ed Sheeran）。 但是，如果您尝试听其他艺术家的音乐，您可能会喜欢比 Ed Sheeran（探索）更好的人。 关于您是否只需要听 Ed Sheeran（利用）还是尝试听不同的艺术家以查看您是否喜欢他们（利用）的这种困惑称为探索利用难题。
 
-因此，为了避免这种困境，我们引入了一种称为 epsilon-greedy 策略的新策略。 在这里，所有动作均以非零概率（ε）进行尝试。 对于概率ε，我们随机地探索不同的动作，而对于概率 1，我们选择具有最大值的动作，即，我们不进行任何探索。 因此，我们不仅会以概率ε始终利用最佳行动，而且还会随机探索不同的行动。 如果 epsilon 的值设置为零，那么我们将不做任何探索。 这只是贪婪的策略，如果将 epsilon 的值设置为 1，则它将始终仅进行探索。 epsilon 的值会随着时间的流逝而衰减，因为我们不想永远探索。 因此，随着时间的流逝，我们的策略会采取良好的行动：
+因此，为了避免这种困境，我们引入了一种称为`ε`贪婪策略的新策略。 在这里，所有动作均以非零概率（`ε`）进行尝试。 对于概率`ε`，我们随机地探索不同的动作，而对于概率 1，我们选择具有最大值的动作，即，我们不进行任何探索。 因此，我们不仅会以概率`ε`始终利用最佳行动，而且还会随机探索不同的行动。 如果`epsilon`的值设置为零，那么我们将不做任何探索。 这只是贪婪的策略，如果将`epsilon`的值设置为 1，则它将始终仅进行探索。`epsilon`的值会随着时间的流逝而衰减，因为我们不想永远探索。 因此，随着时间的流逝，我们的策略会采取良好的行动：
 
 ![](img/00105.gif)
 
-假设我们将 epsilon 的值设置为`0.3`。 在下面的代码中，我们从均匀分布中生成一个随机值，如果该值小于 epsilon 值，即 0.3，则选择一个随机动作（以这种方式，我们搜索一个不同的动作）。 如果来自均匀分布的随机值大于 0.3，则我们选择具有最佳值的操作。 因此，通过这种方式，我们以概率 epsilon 探索了以前从未见过的动作，并从概率为 1-epsilon 的探索动作中选择了最佳动作：
+假设我们将`epsilon`的值设置为`0.3`。 在下面的代码中，我们从均匀分布中生成一个随机值，如果该值小于`epsilon`值，即 0.3，则选择一个随机动作（以这种方式，我们搜索一个不同的动作）。 如果来自均匀分布的随机值大于 0.3，则我们选择具有最佳值的操作。 因此，通过这种方式，我们以概率`epsilon`探索了以前从未见过的动作，并从概率为  1 `epsilon`的探索动作中选择了最佳动作：
 
 ```py
 def epsilon_greedy_policy(state, epsilon):
@@ -551,7 +551,7 @@ def epsilon_greedy_policy(state, epsilon):
          return max(list(range(env.action_space.n)), key = lambda x: q[(state,x)])
 ```
 
-让我们想象一下，我们已经使用 epsilon-greedy 策略探索了状态 1 中的其他动作（尽管不是所有动作对），并且我们的 Q 表如下所示：
+让我们想象一下，我们已经使用`ε`贪婪策略探索了状态 1 中的其他动作（尽管不是所有动作对），并且我们的 Q 表如下所示：
 
 | **状态** | **动作** | **值** |
 | 状态 1 | 动作 0 | 0.5 |
@@ -559,19 +559,19 @@ def epsilon_greedy_policy(state, epsilon):
 | 状态 1 | 动作 2 | 0.8 |
 | 状态 1 | 动作 4 | 0.93 |
 
-在状态 1 中，动作 4 具有比我们之前发现的动作 2 高的值。 因此，在 epsilon-greedy 策略下，我们以概率 epsilon 寻找不同的动作，并以概率为 1-epsilon 寻找最佳动作。
+在状态 1 中，动作 4 具有比我们之前发现的动作 2 高的值。 因此，在`ε`贪婪策略下，我们以概率`epsilon`寻找不同的动作，并以概率为 1 `epsilon`寻找最佳动作。
 
 策略性蒙特卡洛方法涉及的步骤非常简单：
 
 1.  首先，我们初始化随机策略和随机 Q 函数。
-2.  然后，我们初始化一个称为 return 的列表，用于存储退货。
-3.  我们使用随机策略π生成情节。
+2.  然后，我们初始化一个称为`return`的列表，用于存储退货。
+3.  我们使用随机策略`π`生成情节。
 4.  我们将情节中发生的每个状态操作对的返回存储到返回列表中。
 
 5.  然后，我们对返回列表中的返回值取平均值，然后将该值分配给`Q`函数。
-6.  现在，由ε决定由状态`s`选择动作`a`的可能性。
-7.  如果概率为 1-ε，我们将选择最大`Q`值的动作。
-8.  如果概率为ε，我们将探索不同的动作。
+6.  现在，由`ε`决定由状态`s`选择动作`a`的可能性。
+7.  如果概率为`1-ε`，我们将选择最大`Q`值的动作。
+8.  如果概率为`ε`，我们将探索不同的动作。
 
 # 脱离策略的蒙特卡洛控制
 
@@ -605,9 +605,9 @@ def epsilon_greedy_policy(state, epsilon):
 
 我们在蒙特卡洛预测中研究了两种不同的方法：首次访问蒙特卡洛预测，其中我们仅在情节中首次访问该状态时才对收益进行平均；以及每次访问蒙特卡洛方法，其中我们将每次 在情节中访问州。
 
-在蒙特卡洛控制方面，我们研究了不同的算法。 我们首先遇到了 MC-ES 控件，该控件用于覆盖所有状态-动作对。 我们研究了策略上的 MC 控制（它使用 epsilon-greedy 策略）和策略外的 MC 控制（一次使用两个策略）。
+在蒙特卡洛控制方面，我们研究了不同的算法。 我们首先遇到了 MC-ES 控件，该控件用于覆盖所有状态-动作对。 我们研究了策略上的 MC 控制（它使用`ε`贪婪策略）和策略外的 MC 控制（一次使用两个策略）。
 
-在下一章[，第 5 章](05.html#3CN040-3c5bb317ad314d43ac43a332c0db6f00)，“时间差异学习”中，我们将介绍一种不同的无模型学习算法。
+在下一章第 5 章，“时间差异学习”中，我们将介绍一种不同的无模型学习算法。
 
 # 问题
 
diff --git a/new/handson-rl-py/05.md b/new/handson-rl-py/05.md
index 034d202114e5b1ec429c2389748bdcee70b6ec45..d7a3867bf17eba8c0f6ef3290d2a523f17979d9b 100644
--- a/new/handson-rl-py/05.md
+++ b/new/handson-rl-py/05.md
@@ -12,7 +12,7 @@
 
 # TD 学习
 
-TD 学习算法由 Sutton 于 1988 年提出。该算法兼顾了 Monte Carlo 方法和**动态规划**（**DP**）的优点。 像蒙特卡洛方法一样，它不需要模型动力学，而像 DP 一样，它不需要等到情节结束就可以估计值函数。 取而代之的是，它基于先前学习的估算值来估算当前估算值，这也称为自举。 如果您在蒙特卡洛方法中看到没有引导程序，那么我们仅在情节结束时进行估计，但在 TD 方法中我们可以进行引导。
+TD 学习算法由 Sutton 于 1988 年提出。该算法兼顾了蒙特卡洛方法和**动态规划**（**DP**）的优点。 像蒙特卡洛方法一样，它不需要模型动力学，而像 DP 一样，它不需要等到情节结束就可以估计值函数。 取而代之的是，它基于先前学习的估算值来估算当前估算值，这也称为自举。 如果您在蒙特卡洛方法中看到没有引导程序，那么我们仅在情节结束时进行估计，但在 TD 方法中我们可以进行引导。
 
 # TD 预测
 
@@ -105,7 +105,7 @@ V(s) = -0.0315
 前面的公式与 TD 预测更新规则相似，只是有一点点差异。 我们将逐步详细介绍这一点。 Q 学习涉及的步骤如下：
 
 1.  首先，我们将`Q`函数初始化为一些任意值
-2.  我们使用 epsilon-greedy 策略（![](img/00122.jpeg)）从某个州采取了一项行动，并将其移至新的州
+2.  我们使用`ε`贪婪策略（![](img/00122.jpeg)）从某个州采取了一项行动，并将其移至新的州
 3.  我们通过遵循更新规则来更新先前状态的`Q`值：
 
 ![](img/00123.jpeg)
@@ -114,15 +114,15 @@ V(s) = -0.0315
 
 现在，我们将使用不同的步骤来理解算法。
 
-考虑相同的冻湖示例。 假设我们处于状态（3,2），并且有两个动作（左和右）。 现在让我们参考该图，并将其与 epsilon-greedy 策略进行比较：
+考虑相同的冻湖示例。 假设我们处于状态（3,2），并且有两个动作（左和右）。 现在让我们参考该图，并将其与`ε`贪婪策略进行比较：
 
 ![](img/00124.jpeg)
 
-在“ Q 学习”中，我们使用 epsilon-greedy 策略选择一个动作。 我们要么探索概率为ε的新动作，要么选择概率为 1ε的最佳动作。 假设我们选择一个概率`ε`，并探索一个新的动作**向下**，然后选择该动作：
+在“ Q 学习”中，我们使用`ε`贪婪策略选择一个动作。 我们要么探索概率为ε的新动作，要么选择概率为 1ε的最佳动作。 假设我们选择一个概率`ε`，并探索一个新的动作**向下**，然后选择该动作：
 
 ![](img/00125.jpeg)
 
-现在，我们已经对状态`(3, 2)`执行了向下操作，并使用 epsilon-greedy 策略达到了新状态`(4, 2)`，我们如何更新 使用我们的更新规则的先前状态`(3, 2)`的值？ 这很简单。 查看`Q`表，如下所示：
+现在，我们已经对状态`(3, 2)`执行了向下操作，并使用`ε`贪婪策略达到了新状态`(4, 2)`，我们如何更新 使用我们的更新规则的先前状态`(3, 2)`的值？ 这很简单。 查看`Q`表，如下所示：
 
 ![](img/00126.jpeg)
 
@@ -136,7 +136,7 @@ Q( (3,2) down) = Q( (3,2), down ) + 0.1 ( 0.3 + 1 max [Q( (4,2) action) ]- Q( (3
 
 我们可以说具有向下作用的状态`(3, 2)`的值，例如`Q((3, 2), down)`的值为`Q`表中的`0.8`。
 
-状态`(4, 2)`的最大值`Q((4, 2), op)`是什么？ 我们仅研究了三个动作（**向上**，**向下**和**向右**），因此我们将仅基于这些动作来获取最大值。 （此处，我们将不执行 epsilon 贪婪策略；我们仅选择具有最大值的操作。）
+状态`(4, 2)`的最大值`Q((4, 2), op)`是什么？ 我们仅研究了三个动作（**向上**，**向下**和**向右**），因此我们将仅基于这些动作来获取最大值。 （此处，我们将不执行`epsilon`贪婪策略；我们仅选择具有最大值的操作。）
 
 因此，基于先前的`Q`表，我们可以将值替换为：
 
@@ -148,9 +148,9 @@ Q( (3,2), down) = 0.8 + 0.1 ( 0.3 + 1 max [0.3, 0.5, 0.8] - 0.8 )
 
 因此，我们将`Q((3, 2), down)`的值更新为`0.83`。
 
-请记住，在选择要采取的操作时，我们将执行 epsilon-greedy 策略：我们要么探索具有概率 epsilon 的新操作，要么采取具有最大值的概率 1-epsilon。 在更新 Q 值时，我们不执行 epsilon-greedy 策略，我们仅选择具有最大值的操作。
+请记住，在选择要采取的操作时，我们将执行`ε`贪婪策略：我们要么探索具有概率`epsilon`的新操作，要么采取具有最大值的概率 1-epsilon。 在更新 Q 值时，我们不执行`ε`贪婪策略，我们仅选择具有最大值的操作。
 
-现在我们处于状态`(4, 2)`，我们必须执行一个动作。 我们应该执行什么动作？ 我们决定基于 epsilon-greedy 策略，要么探索具有概率 epsilon 的新操作，要么选择具有概率 *1-epsilon* 的最佳操作。 假设我们选择概率`1-ε`，然后选择最佳操作。 因此，在`(4, 2)`中，向右的操作具有最大值。 因此，我们将选择**向右**操作：
+现在我们处于状态`(4, 2)`，我们必须执行一个动作。 我们应该执行什么动作？ 我们决定基于`ε`贪婪策略，要么探索具有概率`epsilon`的新操作，要么选择具有概率 *1-epsilon* 的最佳操作。 假设我们选择概率`1-ε`，然后选择最佳操作。 因此，在`(4, 2)`中，向右的操作具有最大值。 因此，我们将选择**向右**操作：
 
 ![](img/00128.jpeg)
 
@@ -160,7 +160,7 @@ Q( (3,2), down) = 0.8 + 0.1 ( 0.3 + 1 max [0.3, 0.5, 0.8] - 0.8 )
 Q( (4,2), right) = Q( (4,2), right ) + 0.1 ( 0.3 + 1 max [Q( (4,3) action) ]- Q( (4,2), right)
 ```
 
-如果您查看下面的`Q`表，对于状态`(4, 3)`，我们仅探讨了两个操作（**向上**和**向下**），因此我们仅根据这些操作得出最大值。 （这里，我们将不执行 epsilon-greedy 策略；我们只选择具有最大值的操作）：
+如果您查看下面的`Q`表，对于状态`(4, 3)`，我们仅探讨了两个操作（**向上**和**向下**），因此我们仅根据这些操作得出最大值。 （这里，我们将不执行`ε`贪婪策略；我们只选择具有最大值的操作）：
 
 ```
 Q ( (4,2), right) = Q((4,2),right) + 0.1 (0.3 + 1 max [ (Q (4,3), up) , ( Q(4,3),down) ] - Q ((4,2), right )
@@ -176,7 +176,7 @@ Q ( (4,2), right) = 0.8 + 0.1 (0.3 + 1 max [ 0.1,0.3] - 0.8)
 
 现在我们将状态`Q((4,2), right)`的值更新为`0.78`。
 
-因此，这就是我们在 Q 学习中获得状态作用值的方式。 为了决定采取什么行动，我们使用 epsilon-greedy 策略，并在更新`Q`值时，我们只选择最大的行动； 这是流程图：
+因此，这就是我们在 Q 学习中获得状态作用值的方式。 为了决定采取什么行动，我们使用`ε`贪婪策略，并在更新`Q`值时，我们只选择最大的行动； 这是流程图：
 
 ![](img/00130.gif)
 
@@ -234,7 +234,7 @@ def update_q_table(prev_state, action, reward, nextstate, alpha, gamma):
     q[(prev_state,action)] += alpha * (reward + gamma * qa -q[(prev_state,action)])
 ```
 
-然后，我们定义一个函数以执行 epsilon-greedy 策略，并在其中传递状态和 epsilon 值。 我们生成一些均匀分布的随机数，如果该数小于 epsilon，则在状态中探索不同的动作，否则我们将利用具有最大 q 值的动作：
+然后，我们定义一个函数以执行`ε`贪婪策略，并在其中传递状态和`epsilon`值。 我们生成一些均匀分布的随机数，如果该数小于 epsilon，则在状态中探索不同的动作，否则我们将利用具有最大 q 值的动作：
 
 ```py
 
@@ -319,7 +319,7 @@ for i in range(8000):
 
         env.render()
 
-        # In each state, we select the action by epsilon-greedy policy
+        # In each state, we select the action by`ε`贪婪policy
         action = epsilon_greedy_policy(prev_state, epsilon)
 
         # then we perform the action and move to the next state, and 
@@ -356,10 +356,10 @@ env.close()
 在前面的等式中，您可能会注意到，没有最大的`Q(s', a')`，就像在 Q 学习中一样。 这里只是`Q(s', a')`。 我们可以通过执行一些步骤来详细了解这一点。 SARSA 涉及的步骤如下：
 
 1.  首先，我们将`Q`值初始化为一些任意值
-2.  我们通过 epsilon-greedy 策略（![](img/00134.jpeg)）选择一个动作，然后从一种状态转移到另一种状态
+2.  我们通过`ε`贪婪策略（![](img/00134.jpeg)）选择一个动作，然后从一种状态转移到另一种状态
 3.  我们遵循更新规则![](img/00135.jpeg)来更新`Q`值的先前状态，其中`a'`是由`ε`贪婪策略（![](img/00136.jpeg)）选择的操作
 
-现在，我们将逐步了解算法。 让我们考虑相同的冰冻湖的例子。 假设我们处于`(4, 2)`状态。 我们根据 epsilon-greedy 策略决定采取的措施。 假设我们使用概率为 1-epsilon 并选择最佳操作，即**向右**：
+现在，我们将逐步了解算法。 让我们考虑相同的冰冻湖的例子。 假设我们处于`(4, 2)`状态。 我们根据`ε`贪婪策略决定采取的措施。 假设我们使用概率为 1 `epsilon`并选择最佳操作，即**向右**：
 
 ![](img/00137.jpeg)
 
@@ -371,13 +371,13 @@ env.close()
 Q( (4,2), right) = Q( (4,2),right) + 0.1 ( 0.3 + 1 Q( (4,3), action)) - Q((4,2) , right)
 ```
 
-我们如何选择`Q((4, 3), action)`的值？ 在这里，与 Q 学习不同，我们不只是获取`max Q((4, 3), action)`。 在 SARSA 中，我们使用 epsilon-greedy 策略。
+我们如何选择`Q((4, 3), action)`的值？ 在这里，与 Q 学习不同，我们不只是获取`max Q((4, 3), action)`。 在 SARSA 中，我们使用`ε`贪婪策略。
 
 查看下面的 Q 表。 在状态`(4, 3)`中，我们探索了两个动作。 与 Q 学习不同，我们不会直接选择最大动作：
 
 ![](img/00139.jpeg)
 
-我们在这里也遵循 epsilon-greedy 策略。 我们要么以概率 epsilon 进行探索，要么以概率 1 epsilon 进行利用。 假设我们选择概率ε并探索新的动作。 我们探索一个新动作**向右**，然后选择该动作：
+我们在这里也遵循`ε`贪婪策略。 我们要么以概率`epsilon`进行探索，要么以概率 1`epsilon`进行利用。 假设我们选择概率ε并探索新的动作。 我们探索一个新动作**向右**，然后选择该动作：
 
 ![](img/00140.jpeg)
 
@@ -389,7 +389,7 @@ Q ( (4,2), right) = 0.8 + 0.1 (0.3 + 1(0.9) - 0.8)
     = 0.84
 ```
 
-因此，这就是我们在 SARSA 中获取状态操作值的方式。 我们使用 epsilon-greedy 策略采取措施，并且在更新 Q 值的同时，我们使用 epsilon-greedy 策略采取措施。
+因此，这就是我们在 SARSA 中获取状态操作值的方式。 我们使用`ε`贪婪策略采取措施，并且在更新 Q 值的同时，我们使用`ε`贪婪策略采取措施。
 
 下图说明了 SARSA 算法：
 
@@ -545,7 +545,7 @@ Q 学习和 SARSA 对许多人来说总是很困惑。 让我们分解一下两
 
 ![](img/00142.gif)
 
-您看得出来差别吗？ 在 Q 学习中，我们使用 epsilon-greedy 策略采取行动，并且在更新 Q 值的同时，我们仅采取最大行动。 在 SARSA 中，我们使用 epsilon-greedy 策略采取措施，并且在更新 Q 值的同时，我们使用 epsilon-greedy 策略采取措施。
+您看得出来差别吗？ 在 Q 学习中，我们使用`ε`贪婪策略采取行动，并且在更新 Q 值的同时，我们仅采取最大行动。 在 SARSA 中，我们使用`ε`贪婪策略采取措施，并且在更新 Q 值的同时，我们使用`ε`贪婪策略采取措施。
 
 # 概要
 
diff --git a/new/handson-rl-py/06.md b/new/handson-rl-py/06.md
index 05fb421dd4c236a0401b7bf26eb4dc9107024907..4461674e972b202af6bcf65edfa3f60531223c74 100644
--- a/new/handson-rl-py/06.md
+++ b/new/handson-rl-py/06.md
@@ -5,7 +5,7 @@
 在本章中，您将了解以下内容：
 
 *   MAB 问题
-*   epsilon-greedy 算法
+*  `ε`贪婪算法
 *   softmax 探索算法
 *   置信区间上限算法
 *   汤普森采样算法
@@ -73,11 +73,11 @@ env.action_space
 
 # 贪婪策略
 
-我们已经学到了很多关于ε贪婪策略的知识。 在 epsilon-greedy 策略中，或者我们选择概率为 1-epsilon 的最佳手臂，或者我们随机选择概率为 epsilon 的手臂：
+我们已经学到了很多关于ε贪婪策略的知识。 在`ε`贪婪策略中，或者我们选择概率为 1 `epsilon`的最佳手臂，或者我们随机选择概率为`epsilon`的手臂：
 
 ![](img/00146.gif)
 
-现在，我们将看到如何使用 epsilon-greedy 策略选择最佳手臂：
+现在，我们将看到如何使用`ε`贪婪策略选择最佳手臂：
 
 1.  首先，让我们初始化所有变量：
 
@@ -140,7 +140,7 @@ The optimal arm is 3
 
 # softmax 探索算法
 
-Softmax 探索（也称为 Boltzmann 探索）是用于找到最佳老虎机的另一种策略。 在 epsilon-greedy 策略中，我们等效地考虑所有非最佳分支，但是在 softmax 探索中，我们根据来自 Boltzmann 分布的概率选择一个分支。 选择手臂的概率由下式给出：
+Softmax 探索（也称为 Boltzmann 探索）是用于找到最佳老虎机的另一种策略。 在`ε`贪婪策略中，我们等效地考虑所有非最佳分支，但是在 softmax 探索中，我们根据来自 Boltzmann 分布的概率选择一个分支。 选择手臂的概率由下式给出：
 
 ![](img/00147.jpeg)
 
@@ -211,7 +211,7 @@ The optimal arm is 3
 
 # 置信区间上限算法
 
-通过 epsilon-greedy 和 softmax 探索，我们以概率探索了随机动作。 随机动作对于探索各种武器很有用，但也可能导致我们尝试无法给我们带来丰厚回报的动作。 我们也不想错过实际上是好的武器，但在最初的回合中却给出了差的奖励。 因此，我们使用一种称为**上置信界上限**（**UCB**）的新算法。 它基于面对不确定性时称为乐观的原则。
+通过`ε`贪婪和 softmax 探索，我们以概率探索了随机动作。 随机动作对于探索各种武器很有用，但也可能导致我们尝试无法给我们带来丰厚回报的动作。 我们也不想错过实际上是好的武器，但在最初的回合中却给出了差的奖励。 因此，我们使用一种称为**上置信界上限**（**UCB**）的新算法。 它基于面对不确定性时称为乐观的原则。
 
 UCB 算法可帮助我们根据置信区间选择最佳分支。 好的，置信区间是多少？ 让我们说我们有两条手臂。 我们拉开这两个手臂，发现第一手臂给了我们 0.3 奖励，第二手臂给了我们 0.8 奖励。 但是，随着一轮拉动手臂，我们不应该得出这样的结论：第二臂将给我们最好的回报。 我们必须尝试几次拉动手臂，取每个手臂获得的奖励平均值，然后选择平均值最高的手臂。 但是，我们如何才能找到每个臂的正确平均值？ 这是置信区间进入图片的位置。 置信区间指定武器平均奖励值所在的区间。 如果手臂 1 的置信区间为`[0.2, 0.9]`，则表示手臂 1 的平均值在此区间 0.2 至 0.9 内。 0.2 称为下置信界，而 0.9 称为 UCB。 UCB 选择具有较高 UCB 的机器进行探索。
 
@@ -445,7 +445,7 @@ Q = np.zeros(num_banner)
 sum_rewards = np.zeros(num_banner)
 ```
 
-定义 epsilon-greedy 策略：
+定义`ε`贪婪策略：
 
 ```py
 def epsilon_greedy(epsilon):
@@ -489,7 +489,7 @@ sns.distplot(banner_selected)
 
 # 概要
 
-在本章中，我们了解了 MAB 问题以及如何将其应用于不同的应用程序。 我们了解了解决探索-利用困境的几种方法。 首先，我们查看了 epsilon-greedy 策略，在其中我们以概率 epsilon 进行了探索，并以概率 1-epsilon 进行了探索。 我们查看了 UCB 算法，在该算法中我们选择了具有最大上限值的最佳操作，其次是 TS 算法，在此我们通过 beta 分布获得了最佳操作。
+在本章中，我们了解了 MAB 问题以及如何将其应用于不同的应用程序。 我们了解了解决探索-利用困境的几种方法。 首先，我们查看了`ε`贪婪策略，在其中我们以概率`epsilon`进行了探索，并以概率 1 `epsilon`进行了探索。 我们查看了 UCB 算法，在该算法中我们选择了具有最大上限值的最佳操作，其次是 TS 算法，在此我们通过 beta 分布获得了最佳操作。
 
 在接下来的章节中，我们将学习深度学习以及如何使用深度学习解决 RL 问题。
 
@@ -499,7 +499,7 @@ sns.distplot(banner_selected)
 
 1.  什么是 MAB 问题？
 2.  什么是探索利用困境？
-3.  epsilon 在 epsilon-greedy 策略中有何意义？
+3. `epsilon`在`ε`贪婪策略中有何意义？
 4.  我们如何解决探索与利用的困境？
 5.  什么是 UCB 算法？
 6.  汤普森采样与 UCB 算法有何不同？
diff --git a/new/handson-rl-py/08.md b/new/handson-rl-py/08.md
index 0fd2b4999fe55e2557e3d37bd6f2f64862fe9b6b..b6c11cfa2293c0fdd3da143b6c2cb940aa649e29 100644
--- a/new/handson-rl-py/08.md
+++ b/new/handson-rl-py/08.md
@@ -81,7 +81,7 @@ DQN 的第一层是卷积网络，网络的输入将是游戏屏幕的原始帧
 现在，我们将了解 DQN 的整体工作方式。 DQN 涉及的步骤如下：
 
 1.  首先，我们预处理游戏屏幕（状态`s`）并将其馈送到 DQN，DQN 将返回该状态下所有可能动作的`Q`值。
-2.  现在，我们使用 epsilon-greedy 策略选择一个动作：对于概率 epsilon，我们选择一个随机动作`a`；对于概率为 1-epsilon，我们选择一个具有最大`Q`的动作 ]值，例如![](img/00258.jpeg)。
+2.  现在，我们使用`ε`贪婪策略选择一个动作：对于概率 epsilon，我们选择一个随机动作`a`；对于概率为 1-epsilon，我们选择一个具有最大`Q`的动作 ]值，例如![](img/00258.jpeg)。
 3.  在选择动作`a`之后，我们在`s`状态下执行此动作，然后移至新的`s'`状态并获得奖励。 下一个状态`s'`是下一个游戏屏幕的预处理图像。
 4.  我们将此转移存储在`<s,a,r,s'>`的回放缓冲区中。
 5.  接下来，我们从回放缓冲区中抽取一些随机的转移批次并计算损失。
@@ -180,9 +180,9 @@ def q_network(X, name_scope):
         return vars, output
 ```
 
-接下来，我们定义一个`epsilon_greedy`函数以执行 epsilon-greedy 策略。 在 epsilon-greedy 策略中，我们选择概率为 1 epsilon 的最佳操作，或者选择概率为 epsilon 的随机操作。
+接下来，我们定义一个`epsilon_greedy`函数以执行`ε`贪婪策略。 在`ε`贪婪策略中，我们选择概率为 1`epsilon`的最佳操作，或者选择概率为`epsilon`的随机操作。
 
-我们使用衰减的 epsilon 贪婪策略，其中 epsilon 的值会随着时间的流逝而衰减，因为我们不想永远探索。 因此，随着时间的流逝，我们的策略只会利用良好的行动：
+我们使用衰减的`epsilon`贪婪策略，其中`epsilon`的值会随着时间的流逝而衰减，因为我们不想永远探索。 因此，随着时间的流逝，我们的策略只会利用良好的行动：
 
 ```py
 epsilon = 0.5
diff --git a/new/handson-rl-py/09.md b/new/handson-rl-py/09.md
index d3a4ffccb43f41c66547f5ac20ead66376f37409..8cd68da6e0e0d19f98478fc5c35c01ab723db18c 100644
--- a/new/handson-rl-py/09.md
+++ b/new/handson-rl-py/09.md
@@ -44,7 +44,7 @@ pip install vizdoom
 
 ViZDoom 提供了许多 Doom 方案，可以在软件包文件夹`vizdoom/scenarios`中找到这些方案。
 
-# 基本厄运游戏
+# 基本Doom游戏
 
 在开始之前，让我们通过看一个基本示例来熟悉`vizdoom`环境：
 
@@ -119,7 +119,7 @@ for i in range(no_of_episodes):
 
 ![](img/00289.jpeg)
 
-# DRQN 的厄运
+# DRQN 的Doom
 
 现在，让我们看看如何利用 DRQN 算法来训练我们的特工玩《毁灭战士》。 我们为成功杀死怪物分配正面奖励，为失去生命，自杀和失去弹药（子弹）分配负面奖励。 您可以在[这里](https://github.com/sudharsan13296/Hands-On-Reinforcement-Learning-With-Python/blob/master/09.%20Playing%20Doom%20Game%20using%20DRQN/9.5%20Doom%20Game%20Using%20DRQN.ipynb)获得 Jupyter 笔记本的完整代码及其解释。 本节中使用的代码的权利归于 [Luthanicus](https://github.com/Luthanicus/losaltoshackathon-drqn)。
 
@@ -583,7 +583,7 @@ DARQN 的架构如下所示：
 
 在本章中，我们学习了如何使用 DRQN 记住有关先前状态的信息，以及它如何克服部分可观察的 MDP 问题。 我们已经看到了如何训练我们的特工使用 DRQN 算法玩《毁灭战士》游戏。 我们还了解了 DARQN 作为 DRQN 的改进，它在卷积层的顶部增加了一个关注层。 在此之后，我们看到了两种类型的注意力机制： 即软硬关注。
 
-在下一章第 10 章，“异步优势参与者评论者网络”中，我们将学习另一种有趣的深度强化学习算法，称为异步优势参与者批评者网络。
+在下一章第 10 章，“异步优势参与者评论者网络”中，我们将学习另一种有趣的深度强化学习算法，称为异步优势演员评论家网络。
 
 # 问题
 
diff --git a/new/handson-rl-py/10.md b/new/handson-rl-py/10.md
index 37abbb0cbc03c7c68e4027f5c61a9738a3e231c0..87c98afaae40eedcdb0a0a8f6f499cf3532f3f99 100644
--- a/new/handson-rl-py/10.md
+++ b/new/handson-rl-py/10.md
@@ -21,7 +21,7 @@ A3C 网络风起云涌，并接管了 DQN。 除了前面提到的优点之外
 
 在 A3C 中，第一个 A，**异步**表示其工作方式。 在这里，我们有多个与环境交互的代理，而不是像 DQN 那样有单个代理尝试学习最佳策略。 由于我们有多个代理同时与环境交互，因此我们将环境的副本提供给每个代理，以便每个代理可以与自己的环境副本进行交互。 因此，所有这些多个代理都称为辅助代理，我们有一个单独的代理，称为全局网络，所有代理都向其报告。 全球网络汇集了学习内容。
 
-第二个 A 是**优势**； 在讨论 DQN 的决斗网络架构时，我们已经看到了优势功能。 优势函数可以定义为 Q 函数和值函数之间的差。 我们知道 Q 函数指定状态下动作的状态，而 value 函数指定状态下状态的状态。 现在，凭直觉思考； 两者之间的区别意味着什么？ 它告诉我们，与其他所有动作相比，代理在状态`s`下执行动作`a`有多好。
+第二个 A 是**优势**； 在讨论 DQN 的决斗网络架构时，我们已经看到了优势功能。 优势函数可以定义为 Q 函数和值函数之间的差。 我们知道 Q 函数指定状态下动作的状态，而值函数指定状态下状态的状态。 现在，凭直觉思考； 两者之间的区别意味着什么？ 它告诉我们，与其他所有动作相比，代理在状态`s`下执行动作`a`有多好。
 
 第三个 A 是**演员评论家**； 该架构具有两种类型的网络，即参与者和评论者。 演员的角色是学习策略，评论家的角色是评估演员学习的策略有多好。
 
diff --git a/new/handson-rl-py/12.md b/new/handson-rl-py/12.md
index d3dfee6a3279f13cab918c0f6dcfbb5ff12ce13c..7e8668adc5c2ca1304b048ce8ac88c9eb1360dbb 100644
--- a/new/handson-rl-py/12.md
+++ b/new/handson-rl-py/12.md
@@ -491,7 +491,7 @@ class DQN(object):
         self.experience_replay.store(state, action, reward, next_state, is_terminal)
 ```
 
-我们定义了一个`action`函数，用于使用衰减的 epsilon-greedy 策略选择动作：
+我们定义了一个`action`函数，用于使用衰减的`ε`贪婪策略选择动作：
 
 ```py
     def action(self, state, training = False):
@@ -746,7 +746,7 @@ env.monitor.close()
 2.  编写用于回放缓冲区的 Python 代码。
 3.  什么是目标网络？
 4.  编写 Python 代码以获取优先级的经验回放缓冲区。
-5.  创建一个 Python 函数来衰减 epsilon-greedy 策略。
+5.  创建一个 Python 函数来衰减`ε`贪婪策略。
 6.  决斗 DQN 与双 DQN 有何不同？
 7.  创建用于将主要网络权重更新为目标网络的 Python 函数。
 
diff --git a/new/handson-rl-py/13.md b/new/handson-rl-py/13.md
index 4e0b4f4752f5f1b82ef8f595054a659cc213d540..9e2b2c05e3a8189248c97e05b46954b6602939e1 100644
--- a/new/handson-rl-py/13.md
+++ b/new/handson-rl-py/13.md
@@ -131,7 +131,7 @@ MAXQ 值函数分解是 HRL 中最常用的算法之一。 让我们看看 MAXQ
 
 ![](img/00451.jpeg)
 
-现在，我们可以按 Bellman 方程形式重写前面的值函数，如下所示：
+现在，我们可以按贝尔曼方程形式重写前面的值函数，如下所示：
 
 ![](img/00452.jpeg)-（1）
 
@@ -147,7 +147,7 @@ MAXQ 值函数分解是 HRL 中最常用的算法之一。 让我们看看 MAXQ
 
 ![](img/00456.jpeg)
 
-最后，我们可以将 value 函数重新定义为：
+最后，我们可以将值函数重新定义为：
 
 ![](img/00457.gif)
 
diff --git a/new/handson-rl-py/14.md b/new/handson-rl-py/14.md
index f11f4027aef0e652fc28742acdbf7f9b44296436..a10be60412fa10897aab375693b311d6294e12e8 100644
--- a/new/handson-rl-py/14.md
+++ b/new/handson-rl-py/14.md
@@ -30,8 +30,8 @@
 2.  MDP 是马尔可夫链的延伸。 它提供了用于建模决策情况的数学框架。 几乎所有的 RL 问题都可以建模为 MDP。
 3.  请参阅“折扣系数”部分。
 4.  折扣系数决定了我们对未来奖励和即时奖励的重视程度。
-5.  我们使用 Bellman 函数求解 MDP。
-6.  有关值和 Q 函数的信息，请参见“推导 Bellman 方程”部分。
+5.  我们使用贝尔曼函数求解 MDP。
+6.  有关值和 Q 函数的信息，请参见“推导贝尔曼方程”部分。
 7.  值函数指定状态的优劣，而 Q 函数指定状态下的行为的优劣。
 8.  请参阅“值迭代”和“策略迭代”部分。
 
@@ -52,14 +52,14 @@
 2.  实际值与预测值之差称为 TD 误差
 3.  请参阅“TD 预测”和“TD 控制”部分
 4.  请参阅“使用 Q 学习解决滑行问题”部分
-5.  在 Q 学习中，我们使用 epsilon-greedy 策略采取行动，并且在更新 Q 值的同时，我们仅采取最大行动。 在 SARSA 中，我们使用 epsilon-greedy 策略采取措施，并且在更新 Q 值的同时，我们使用 epsilon-greedy 策略采取措施。
+5.  在 Q 学习中，我们使用`ε`贪婪策略采取行动，并且在更新 Q 值的同时，我们仅采取最大行动。 在 SARSA 中，我们使用`ε`贪婪策略采取措施，并且在更新 Q 值的同时，我们使用`ε`贪婪策略采取措施。
 
 # 第六章
 
 1.  MAB 实际上是一台老虎机，是一种在赌场玩的赌博游戏，您可以拉动手臂（杠杆）并根据随机生成的概率分布获得支出（奖励）。 一台老虎机称为单臂老虎机，当有多台老虎机时，称为多臂老虎机或 k 臂老虎机。
 2.  当业务代表不确定是使用以前的经验来探索新动作还是利用最佳动作时，就会出现探索-利用困境。
 3.  ε用于确定代理是否应使用 1-ε进行探索或利用我们选择最佳作用的作用，而使用ε则探索新作用。
-4.  我们可以使用各种算法（例如 epsilon-greedy 策略，softmax 探索，UCB，Thompson 采样）解决探索-利用难题。
+4.  我们可以使用各种算法（例如`ε`贪婪策略，softmax 探索，UCB，Thompson 采样）解决探索-利用难题。
 5.  UCB 算法可帮助我们根据置信区间选择最佳分支。
 6.  在 Thomson 抽样中，我们使用先验分布进行估算，而在 UCB 中，我们使用置信区间进行估算。
 
@@ -87,7 +87,7 @@
 
 1.  DRQN 利用**循环神经网络**（**RNN**），其中 DQN 利用香草神经网络。
 2.  当可以部分观察 MDP 时，不使用 DQN。
-3.  请参阅“DRQN 的厄运”部分。
+3.  请参阅“DRQN 的Doom”部分。
 4.  与 DRQN 不同，DARQN 利用注意力机制。
 5.  DARQN 用于理解和专注于游戏屏幕的特定区域，这一点更为重要。
 6.  软硬注意。
diff --git a/new/intel-proj-py/01.md b/new/intel-proj-py/01.md
index 53034736d2befec9dcfd4fc269b98f6978f55a11..42930e9a038d5eb05e501d76fd5a6c791c7243a0 100644
--- a/new/intel-proj-py/01.md
+++ b/new/intel-proj-py/01.md
@@ -428,7 +428,7 @@ Figure 1.14: GAN architecture 
 
 # Q 学习
 
-现在，我们将研究一种流行的强化学习算法，称为 **Q 学习**。 Q 学习用于确定给定的有限 Markov 决策过程的最佳动作选择策略。 **马尔可夫决策过程**由状态空间`S`； 一个动作空间`A`； 立即奖励集`R`； 给定当前状态`s[t]`的下一个状态的概率`S[t + 1]`； 当前动作`a[t]`； `P(S[t+1]/S[t];r[t])`; 和折扣系数`γ`定义。 下图说明了马尔可夫决策过程，其中下一个状态取决于当前状态以及在当前状态下执行的任何操作：
+现在，我们将研究一种流行的强化学习算法，称为 **Q 学习**。 Q 学习用于确定给定的有限马尔可夫决策过程的最佳动作选择策略。 **马尔可夫决策过程**由状态空间`S`； 一个动作空间`A`； 立即奖励集`R`； 给定当前状态`s[t]`的下一个状态的概率`S[t + 1]`； 当前动作`a[t]`； `P(S[t+1]/S[t];r[t])`; 和折扣系数`γ`定义。 下图说明了马尔可夫决策过程，其中下一个状态取决于当前状态以及在当前状态下执行的任何操作：
 
 ![](img/83330458-c0b9-4660-a1e3-6cd4927244a6.png)
 
diff --git a/new/intel-proj-py/09.md b/new/intel-proj-py/09.md
index 251202d585b35c71e76460c01768a3020a9b12ce..ac8f098f4ee33a1353c01b18eb7c91902d1d7128 100644
--- a/new/intel-proj-py/09.md
+++ b/new/intel-proj-py/09.md
@@ -254,7 +254,7 @@ class DQN:
 
 # 设计代理
 
-该代理将与环境交互，并在给定状态的情况下，尝试执行最佳操作。 代理最初将执行随机动作，并且随着训练的进行，动作将更多地基于给定状态的 Q 值。 `epsilon`参数的值确定操作是随机的概率。 最初，将`ε`设置为`1`，以使操作随机。 当代理已收集指定数量的训练样本时，在每个步骤中都会减少ε，从而减少了随机动作的可能性。 这种基于ε值的作用的方案称为 Epsilon 贪婪算法。 我们定义两个代理类，如下所示：
+该代理将与环境交互，并在给定状态的情况下，尝试执行最佳操作。 代理最初将执行随机动作，并且随着训练的进行，动作将更多地基于给定状态的 Q 值。 `epsilon`参数的值确定操作是随机的概率。 最初，将`ε`设置为`1`，以使操作随机。 当代理已收集指定数量的训练样本时，在每个步骤中都会减少ε，从而减少了随机动作的可能性。 这种基于ε值的作用的方案称为`epsilon`贪婪算法。 我们定义两个代理类，如下所示：
 
 *   `Agent`：基于给定状态的 Q 值执行动作
 *   `RandomAgent`：执行随机动作