使用 Pong 从像素进行深度强化学习

警告

由于底层gym和atari-py依赖项的许可/安装问题，本文当前尚未经过测试。通过开发一个减少依赖足迹的示例来帮助改进本文！

本教程演示如何使用策略梯度方法从头开始实现深度强化学习 (RL) 代理，该方法学习使用屏幕像素作为 NumPy 的输入来玩Pong视频游戏。您的 Pong 代理将使用人工神经网络作为其策略来获取移动经验。

Pong 是 1972 年推出的一款 2D 游戏，两名玩家使用“球拍”打乒乓球。每个玩家在屏幕上上下移动球拍，并尝试通过触摸对手的方向击球。目标是击球，使其越过对手的球拍（他们的射门失败）。根据规则，如果玩家达到21分，则获胜。在 Pong 中，学习与对手对战的 RL 智能体显示在右侧。

此示例基于Andrej Karpathy于 2017 年在加州大学伯克利分校的Deep RL Bootcamp开发的代码。他2016 年的博客文章还提供了有关 Pong RL 中使用的机制和理论的更多背景知识。

先决条件

• OpenAI Gym：为了帮助游戏环境，您将使用Gym —由 OpenAI 开发的开源 Python 界面，可帮助执行 RL 任务，同时支持许多模拟环境。

• Python 和 NumPy：读者应该具备一定的 Python、NumPy 数组操作和线性代数知识。

• 深度学习和深度强化学习：您应该熟悉深度学习的主要概念，这些概念在Yann LeCun、Yoshua Bengio 和 Geoffrey Hinton 于 2015 年发表的深度学习论文中进行了解释，他们被视为该领域的一些先驱。本教程将尝试引导您了解深度 RL 的主要概念，并且为了您的方便，您将找到带有原始来源链接的各种文献。

• Jupyter 笔记本环境：由于 RL 实验可能需要较高的计算能力，因此您可以使用Binder或Google Colaboratory（提供免费的有限 GPU 和 TPU 加速）在云端免费运行教程。

• Matplotlib：用于绘制图像。查看安装指南以在您的环境中进行设置。

本教程还可以在隔离环境中本地运行，例如Virtualenv和conda。

目录

• 关于 RL 和深度 RL 的注释

• 深度强化学习术语表

1. 设置乒乓球

2. 预处理帧（观察）

3. 创建策略（神经网络）和前向传递

4. 设置更新步骤（反向传播）

5. 定义折扣奖励（预期回报）函数

6. 训练代理 3 集

7. 下一步

8. 附录

   • 关于 RL 和深度 RL 的注释

   • 如何在 Jupyter 笔记本中设置视频播放

---

关于 RL 和深度 RL 的注释

在强化学习中，你的智能体通过使用所谓的策略与环境交互来从试验和错误中学习以获得经验。采取一项行动后，智能体会收到有关其奖励（可能会或可能不会）和下一次环境观察的信息。然后它可以继续采取另一项行动。这种情况会发生多个情节和/或直到任务被认为完成。

代理的策略通过将代理的观察“映射”到其操作来发挥作用，即分配代理观察到的内容与所需操作的表示。总体目标通常是优化代理的策略，以便最大化每次观察的预期奖励。

有关强化学习的详细信息，请参阅Richard Sutton 和 Andrew Barton 编写的一本介绍性书籍。

查看教程末尾的附录以获取更多信息。

深度强化学习术语表

以下是深度强化学习术语的简明词汇表，您可能会发现对本教程的其余部分有用：

• 在有限视野的世界中，例如乒乓球游戏，学习代理可以在一个情节中探索（和利用）环境。代理通常需要很多次才能学习。

• 代理使用actions与环境交互。

• 采取行动后，代理会通过奖励（如果有的话）收到一些反馈，具体取决于它采取的行动及其所处的状态。状态包含有关环境的信息。

• 代理的观察是对状态的部分观察——这是本教程更喜欢的术语（而不是状态）。

• 代理可以根据累积奖励（也称为价值函数）和策略来选择操作。累积奖励函数估计代理使用其策略访问的观察的质量。

• 该策略（由神经网络定义）输出行动选择（作为（对数）概率），该选择应最大化代理所处状态的累积奖励。

• 以行动为条件的观察的预期回报称为行动价值函数。为了给予短期奖励相对于长期奖励更大的权重，您通常使用折扣因子（通常是 0.9 到 0.99 之间的浮点数）。

• 代理“运行”每个策略期间的动作和状态（观察）序列有时被称为轨迹-这样的序列会产生奖励。

您将通过使用策略梯度的“on-policy”方法来训练您的 Pong 代理 - 它是属于基于策略的方法系列的算法。策略梯度方法通常使用机器学习中广泛使用的梯度下降来根据长期累积奖励来更新策略参数。而且，由于目标是最大化函数（奖励），而不是最小化它，因此该过程也称为梯度上升。换句话说，您使用代理采取行动的策略，目标是最大化奖励，这是通过计算梯度并使用它们来更新策略（神经）网络中的参数来实现的。

设置乒乓

1.首先，您应该安装 OpenAI Gym（使用- 该软件包目前在 conda 上不可用），并导入 NumPy、Gym 和必要的模块：pip install gym[atari]

import numpy as np
import gym

Gym 可以使用包装器监视并保存输出Monitor：

from gym import wrappers
from gym.wrappers import Monitor

2.实例化 Pong 游戏的 Gym 环境：

env = gym.make("Pong-v0")

3.让我们回顾一下环境中有哪些操作可用Pong-v0：

print(env.action_space)

print(env.get_action_meanings())

有6个动作。然而，LEFTFIRE实际上是LEFT，RIGHTFIRE—— RIGHT，和NOOP—— FIRE。

为简单起见，您的策略网络将有一个输出 - “向上移动”的（对数）概率（索引为2或RIGHT）。其他可用操作的索引为 3（“下移”或LEFT）。

4. Gym 可以将智能体的学习视频保存为 MP4 格式 -Monitor()通过运行以下命令来环绕环境：

env = Monitor(env, "./video", force=True)

虽然您可以在 Jupyter 笔记本中执行各种 RL 实验，但渲染 Gym 环境的图像或视频以可视化您的代理在训练后如何玩 Pong 游戏可能相当具有挑战性。如果您想在笔记本中设置视频播放，可以在本教程末尾的附录中找到详细信息。

预处理帧（观察）

在本节中，您将设置一个函数来预处理输入数据（游戏观察），使其易于神经网络消化，神经网络只能处理浮点类型张量（多维数组）形式的输入。

您的代理将使用 Pong 游戏中的帧（屏幕帧中的像素）作为策略网络的输入观察。比赛观察告诉代理在将球（通过向前传球）送入神经网络（策略）之前球在哪里。这类似于 DeepMind 的DQN方法（在附录中进一步讨论）。

Pong 屏幕框架为 210x160 像素，具有 3 个颜色维度（红色、绿色和蓝色）。数组使用uint8（或 8 位整数）进行编码，这些观察结果存储在 Gym Box 实例上。

1.检查Pong的观察结果：

print(env.observation_space)

在 Gym 中，代理的动作和观察可以是Box（n 维）或Discrete（固定范围整数）类的一部分。

2.您可以通过以下方式查看随机观察结果（一帧）：

1) Setting the random `seed` before initialization (optional).

2) Calling  Gym's `reset()` to reset the environment, which returns an initial observation.

3) Using Matplotlib to display the `render`ed observation.

（有关Gym核心类和方法的更多信息，您可以参考OpenAI Gym核心API 。）

import matplotlib.pyplot as plt

env.seed(42)
env.reset()
random_frame = env.render(mode="rgb_array")
print(random_frame.shape)
plt.imshow(random_frame)

要将观察结果输入策略（神经）网络，您需要将它们转换为具有 6,400 (80x80x1) 浮点数组的一维灰度向量。 （在训练期间，您将使用 NumPy 的np.ravel()函数来展平这些数组。）

3.设置用于帧（观察）预处理的辅助函数：

def frame_preprocessing(observation_frame):
    # Crop the frame.
    observation_frame = observation_frame[35:195]
    # Downsample the frame by a factor of 2.
    observation_frame = observation_frame[::2, ::2, 0]
    # Remove the background and apply other enhancements.
    observation_frame[observation_frame == 144] = 0  # Erase the background (type 1).
    observation_frame[observation_frame == 109] = 0  # Erase the background (type 2).
    observation_frame[observation_frame != 0] = 1  # Set the items (rackets, ball) to 1.
    # Return the preprocessed frame as a 1D floating-point array.
    return observation_frame.astype(float)

4.预处理之前的随机帧以测试功能 - 策略网络的输入是 80x80 1D 图像：

preprocessed_random_frame = frame_preprocessing(random_frame)
plt.imshow(preprocessed_random_frame, cmap="gray")
print(preprocessed_random_frame.shape)

创建策略（神经网络）和前向传递

接下来，您将将该策略定义为一个简单的前馈网络，该网络使用游戏观察作为输入并输出动作日志概率：

• 对于输入，它将使用 Pong 视频游戏帧 - 具有 6,400 (80x80) 浮点数组的预处理一维向量。

• 隐藏层将使用 NumPy 的数组点积函数计算输入的加权np.dot()和，然后应用非线性激活函数，例如ReLU。

• 然后，输出层将再次执行权重参数和隐藏层输出（与 ）的矩阵乘法，并通过softmax激活函数np.dot()发送该信息。

• 最后，策略网络将为代理输出一个动作日志概率（给定该观察结果）——环境中索引为 2 的 Pong 动作概率（“将球拍向上移动”）。

1.让我们实例化输入层、隐藏层和输出层的某些参数，并开始设置网络模型。

首先为实验创建一个随机数生成器实例（为了重现性而播种）：

rng = np.random.default_rng(seed=12288743)

然后：

• 设置输入（观察）维度 - 您的预处理屏幕框架：

D = 80 * 80

• 设置隐藏层神经元的数量。

H = 200

• 将您的策略​​（神经）网络模型实例化为空字典。

model = {}

在神经网络中，权重是重要的可调节参数，网络通过向前和向后传播数据来微调。

2.使用称为Xavier 初始化的技术，使用 NumPy 设置网络模型的初始权重，Generator.standard_normal()该权重返回标准正态分布上的随机数，以及np.sqrt()：

model["W1"] = rng.standard_normal(size=(H, D)) / np.sqrt(D)
model["W2"] = rng.standard_normal(size=H) / np.sqrt(H)

3.您的策略网络首先随机初始化权重，并将输入数据（帧）从输入层通过隐藏层向前馈送到输出层。这个过程称为前向传播或前向传播，并在函数中概述policy_forward()：

def policy_forward(x, model):
    # Matrix-multiply the weights by the input in the one and only hidden layer.
    h = np.dot(model["W1"], x)
    # Apply non-linearity with ReLU.
    h[h < 0] = 0
    # Calculate the "dot" product in the outer layer.
    # The input for the sigmoid function is called logit.
    logit = np.dot(model["W2"], h)
    # Apply the sigmoid function (non-linear activation).
    p = sigmoid(logit)
    # Return a log probability for the action 2 ("move up")
    # and the hidden "state" that you need for backpropagation.
    return p, h

请注意，有两个激活函数用于确定输入和输出之间的非线性关系。这些非线性函数应用于各层的输出：

• 修正线性单元（ReLU）：定义如上。如果输入为负，则返回 0；如果输入为正，则返回相同的值。h[h<0] = 0

• Sigmoid：定义如下sigmoid()。它“包装”最后一层的输出并返回 (0, 1) 范围内的动作日志概率。

4.使用 NumPy 单独定义 sigmoid 函数np.exp()来计算指数：

def sigmoid(x):
    return 1.0 / (1.0 + np.exp(-x))

设置更新步骤（反向传播）

在深度 RL 算法学习过程中，您可以使用动作日志概率（给定观察）和折扣回报（例如，Pong 中的 +1 或 -1），并执行向后传递或反向传播来更新参数 - 策略网络的重量。

1.让我们借助policy_backward()NumPy 的数组乘法模块定义后向传递函数 ( ) — np.dot()（矩阵乘法）、np.outer()（外积计算）和np.ravel()（将数组展平为一维数组）：

def policy_backward(eph, epdlogp, model):
    dW2 = np.dot(eph.T, epdlogp).ravel()
    dh = np.outer(epdlogp, model["W2"])
    dh[eph <= 0] = 0
    dW1 = np.dot(dh.T, epx)
    # Return new "optimized" weights for the policy network.
    return {"W1": dW1, "W2": dW2}

使用网络的中间隐藏“状态” ( ) 和一个事件的eph动作日志概率梯度 ( )，该函数将梯度传播回策略网络并更新权重。epdlogppolicy_backward

2.在代理训练期间应用反向传播时，您需要为每个情节保存多个变量。让我们实例化空列表来存储它们：

# All preprocessed observations for the episode.
xs = []
# All hidden "states" (from the network) for the episode.
hs = []
# All gradients of probability actions
# (with respect to observations) for the episode.
dlogps = []
# All rewards for the episode.
drs = []

在训练过程中，当这些变量“满”并使用 NumPy 重塑后，您将在每集结束时手动重置这些变量np.vstack()。这在教程结束时的训练阶段得到了演示。

3.接下来，为了在优化代理策略时执行梯度上升，通常使用深度学习优化器（您正在使用梯度执行优化）。在此示例中，您将使用RMSProp — 一种自适应优化方法。让我们为优化器设置一个折扣因子——衰减率：

decay_rate = 0.99

4.您还需要存储np.zeros_like()训练期间优化步骤的梯度（在 NumPy 的帮助下）：

• 首先，保存在批次中添加梯度的更新缓冲区：

grad_buffer = {k: np.zeros_like(v) for k, v in model.items()}

• 其次，为梯度上升优化器存储 RMSProp 内存：

rmsprop_cache = {k: np.zeros_like(v) for k, v in model.items()}

定义折扣奖励（期望回报）函数

在本节中，您将设置一个用于计算折扣奖励 ( discount_rewards()) 的函数（观察的预期回报），该函数使用一维奖励数组作为输入（借助 NumPy 的np.zeros_like()）函数。

为了给短期奖励提供比长期奖励更大的权重，您将使用折扣因子(gamma)，它通常是 0.9 到 0.99 之间的浮点数。

gamma = 0.99


def discount_rewards(r, gamma):
    discounted_r = np.zeros_like(r)
    running_add = 0
    # From the last reward to the first...
    for t in reversed(range(0, r.size)):
        # ...reset the reward sum
        if r[t] != 0:
            running_add = 0
        # ...compute the discounted reward
        running_add = running_add * gamma + r[t]
        discounted_r[t] = running_add
    return discounted_r

训练代理若干集

本节介绍如何设置训练过程，在此过程中您的代理将学习使用其策略打 Pong。

Pong 的策略梯度方法的伪代码：

• 实例化策略（您的神经网络）并随机初始化策略网络中的权重。

• 初始化随机观察。

• 随机初始化策略网络中的权重。

• 重复一些情节：

  • 将观察输入策略网络并输出代理的动作概率（前向传播）。

  • 代理对每个观察采取行动，观察收到的奖励并收集状态行动经验的轨迹（超过预定义的事件数或批量大小）。

  • 计算交叉熵（带有正号，因为您需要最大化奖励而不是最小化损失）。

  • 对于每批剧集：

    • 使用交叉熵计算动作日志概率的梯度。

    • 计算累积回报，并使用折扣因子折扣，为短期奖励提供比长期奖励更大的权重。

    • 将动作日志概率的梯度乘以折扣奖励（“优势”）。

    • 执行梯度上升（反向传播）以优化策略网络的参数（其权重）。

      • 最大化带来高回报的行动的概率。

您可以随时停止训练或/并检查磁盘目录中保存的播放的 MP4 视频/video。您可以设置更适合您的设置的最大剧集数。

1.出于演示目的，我们将训练集数限制为 3。如果您使用硬件加速（CPU 和 GPU），则可以将数量增加到 1,000 或更多。相比之下，Andrej Karpathy 的原始实验大约需要 8,000 集。

max_episodes = 3

2.设置批量大小和学习率值：

• 批量大小决定了模型执行参数更新的频率（以剧集为单位）。这是你的代理可以收集状态动作轨迹的次数。在集合结束时，您可以执行操作概率倍数的最大化。

• 学习率有助于限制权重更新的幅度，以防止它们过度校正。

batch_size = 3
learning_rate = 1e-4

3.为Gym的方法设置游戏渲染默认变量render（用于显示观察结果，是可选的，但在调试过程中很有用）：

render = False

4.通过调用设置代理的初始（随机）观察reset()：

observation = env.reset()

5.初始化之前的观察：

prev_x = None

6.初始化奖励变量和剧集数：

running_reward = None
reward_sum = 0
episode_number = 0

7.要模拟帧之间的运动，请将x策略网络的单个输入帧 ( ) 设置为当前和先前预处理帧之间的差异：

def update_input(prev_x, cur_x, D):
    if prev_x is not None:
        x = cur_x - prev_x
    else:
        x = np.zeros(D)
    return x

8.最后，使用您预定义的函数开始训练循环：

:tags: [output_scroll]

while episode_number < max_episodes:
    # (For rendering.)
    if render:
        env.render()

    # 1. Preprocess the observation (a game frame) and flatten with NumPy's `ravel()`.
    cur_x = frame_preprocessing(observation).ravel()

    # 2. Instantiate the observation for the policy network
    x = update_input(prev_x, cur_x, D)
    prev_x = cur_x

    # 3. Perform the forward pass through the policy network using the observations
    # (preprocessed frames as inputs) and store the action log probabilities
    # and hidden "states" (for backpropagation) during the course of each episode.
    aprob, h = policy_forward(x, model)
    # 4. Let the action indexed at `2` ("move up") be that probability
    # if it's higher than a randomly sampled value
    # or use action `3` ("move down") otherwise.
    action = 2 if rng.uniform() < aprob else 3

    # 5. Cache the observations and hidden "states" (from the network)
    # in separate variables for backpropagation.
    xs.append(x)
    hs.append(h)

    # 6. Compute the gradients of action log probabilities:
    # - If the action was to "move up" (index `2`):
    y = 1 if action == 2 else 0
    # - The cross-entropy:
    # `y*log(aprob) + (1 - y)*log(1-aprob)`
    # or `log(aprob)` if y = 1, else: `log(1 - aprob)`.
    # (Recall: you used the sigmoid function (`1/(1+np.exp(-x)`) to output
    # `aprob` action probabilities.)
    # - Then the gradient: `y - aprob`.
    # 7. Append the gradients of your action log probabilities.
    dlogps.append(y - aprob)
    # 8. Take an action and update the parameters with Gym's `step()`
    # function; obtain a new observation.
    observation, reward, done, info = env.step(action)
    # 9. Update the total sum of rewards.
    reward_sum += reward
    # 10. Append the reward for the previous action.
    drs.append(reward)

    # After an episode is finished:
    if done:
        episode_number += 1
        # 11. Collect and reshape stored values with `np.vstack()` of:
        # - Observation frames (inputs),
        epx = np.vstack(xs)
        # - hidden "states" (from the network),
        eph = np.vstack(hs)
        # - gradients of action log probabilities,
        epdlogp = np.vstack(dlogps)
        # - and received rewards for the past episode.
        epr = np.vstack(drs)

        # 12. Reset the stored variables for the new episode:
        xs = []
        hs = []
        dlogps = []
        drs = []

        # 13. Discount the rewards for the past episode using the helper
        # function you defined earlier...
        discounted_epr = discount_rewards(epr, gamma)
        # ...and normalize them because they have high variance
        # (this is explained below.)
        discounted_epr -= np.mean(discounted_epr)
        discounted_epr /= np.std(discounted_epr)

        # 14. Multiply the discounted rewards by the gradients of the action
        # log probabilities (the "advantage").
        epdlogp *= discounted_epr
        # 15. Use the gradients to perform backpropagation and gradient ascent.
        grad = policy_backward(eph, epdlogp, model)
        # 16. Save the policy gradients in a buffer.
        for k in model:
            grad_buffer[k] += grad[k]
        # 17. Use the RMSProp optimizer to perform the policy network
        # parameter (weight) update at every batch size
        # (by default: every 10 episodes).
        if episode_number % batch_size == 0:
            for k, v in model.items():
                # The gradient.
                g = grad_buffer[k]
                # Use the RMSProp discounting factor.
                rmsprop_cache[k] = (
                    decay_rate * rmsprop_cache[k] + (1 - decay_rate) * g ** 2
                )
                # Update the policy network with a learning rate
                # and the RMSProp optimizer using gradient ascent
                # (hence, there's no negative sign)
                model[k] += learning_rate * g / (np.sqrt(rmsprop_cache[k]) + 1e-5)
                # Reset the gradient buffer at the end.
                grad_buffer[k] = np.zeros_like(v)

        # 18. Measure the total discounted reward.
        running_reward = (
            reward_sum
            if running_reward is None
            else running_reward * 0.99 + reward_sum * 0.01
        )
        print(
            "Resetting the Pong environment. Episode total reward: {} Running mean: {}".format(
                reward_sum, running_reward
            )
        )

        # 19. Set the agent's initial observation by calling Gym's `reset()` function
        # for the next episode and setting the reward sum back to 0.
        reward_sum = 0
        observation = env.reset()
        prev_x = None

    # 20. Display the output during training.
    if reward != 0:
        print(
            "Episode {}: Game finished. Reward: {}...".format(episode_number, reward)
            + ("" if reward == -1 else " POSITIVE REWARD!")
        )

一些注意事项：

• 如果您之前运行过实验并想要重复它，则您的Monitor实例可能仍在运行，这可能会在您下次尝试训练代理时引发错误。因此，您应该首先Monitor通过env.close()取消注释并运行下面的单元格来调用来关闭：

# env.close()

• 在 Pong 中，如果一名球员没有击回球，他们将获得负奖励 (-1)，而另一名球员将获得 +1 奖励。代理通过打 Pong 游戏获得的奖励存在显着差异。因此，最佳实践是使用相同的均值（使用np.mean()）和标准差（使用 NumPy 的np.std()）对它们进行标准化。

• 仅使用 NumPy 时，深度强化学习训练过程（包括反向传播）会跨越几行可能看起来很长的代码。造成这种情况的主要原因之一是您没有使用带有自动微分库的深度学习框架，而自动微分库通常可以简化此类实验。本教程展示了如何从头开始执行所有操作，但您也可以使用带有“autodiff”和“autograd”的许多基于 Python 的框架之一，您将在本教程的最后了解这些框架。

下一步

您可能会注意到，如果将回合数从 100 增加到 500 或 1,000 以上，则训练 RL 代理需要很长时间，具体取决于您用于此任务的硬件（CPU 和 GPU）。

如果你给策略梯度方法大量的时间，它们就可以学习任务，而强化学习中的优化是一个具有挑战性的问题。训练智能体学习打乒乓球或任何其他任务可能样本效率低下，并且需要大量的训练集。您可能还会在训练输出中注意到，即使经过数百次训练，奖励也可能具有很高的方差。

此外，与许多基于深度学习的算法一样，您应该考虑策略必须学习的大量参数。在 Pong 中，网络隐藏层有 200 个节点，输入维度大小为 6,400 (80x80)，这个数字加起来可达 100 万或更多。因此，添加更多 CPU 和 GPU 来协助训练始终是一种选择。

您可以使用更先进的基于策略梯度的算法，该算法可以帮助加快训练速度、提高对参数的敏感性并解决其他问题。例如，有“自我对战”方法，例如John Schulman等人在 2017 年开发的近端策略优化（PPO） ，用于训练OpenAI Five代理超过 10 个月，以达到竞技水平玩 Dota 2。当然，如果您将这些方法应用于较小的健身房环境，那么训练应该需要几个小时，而不是几个月。

一般来说，强化学习存在许多挑战和可能的解决方案，您可以在Matthew Botvinick、Sam Ritter、Jane X. Wang、Zeb Kurth-Nelson、Charles Blundell和Demis Hassabis的《强化学习，快与慢》中探索其中的一些挑战（2019 年） ）。

---

如果您想了解有关深度强化学习的更多信息，您应该查看以下免费教育材料：

• Spinning Up in Deep RL：由 OpenAI 开发。

• 由DeepMind和加州大学伯克利分校的从业者讲授的深度强化学习讲座。

• David Silver（DeepMind，伦敦大学学院）教授的强化学习讲座。

使用 NumPy 从头开始​​构建神经网络是了解 NumPy 和深度学习更多信息的好方法。然而，对于现实世界的应用程序，您应该使用专门的框架 - 例如PyTorch、JAX、TensorFlow或MXNet - 提供类似 NumPy 的 API，具有内置的自动微分和 GPU 支持，并且专为高性能数值计算和机器学习。

附录

关于 RL 和深度 RL 的注释

• 在图像识别、语言翻译或文本分类等任务的监督深度学习中，您更有可能使用大量标记数据。然而，在强化学习中，智能体通常不会收到指示正确或错误操作的直接显式反馈——它们依赖于其他信号，例如奖励。

• 深度强化学习将强化学习与深度学习结合起来。 2013 年，该领域在更复杂的环境（例如视频游戏）中首次取得重大成功——AlexNet在计算机视觉领域取得突破一年后。 Volodymyr Mnih 和 DeepMind 的同事发表了一篇名为《利用深度强化学习玩 Atari》的研究论文（并于 2015 年更新），论文表明他们能够训练一个代理，使其能够在街机学习环境中以人类水平玩一些经典游戏。他们的 RL 算法——称为深度 Q 网络 (DQN)——在神经网络中使用卷积层来近似Q 学习并使用经验回放。

• 与本例中使用的简单策略梯度方法不同，DQN 使用一种基于“离策略”值的方法（近似于 Q 学习），而原始AlphaGo使用策略梯度和蒙特卡罗树搜索。

• Richard Sutton 等人于 2000 年撰写了带有函数逼近的策略梯度（例如神经网络） 。它们受到许多先前工作的影响，包括统计梯度跟踪算法，例如REINFORCE（Ronald Williams，1992），以及有助于深度学习算法学习的反向传播（Geoffrey Hinton，1986）。采用神经网络函数逼近的强化学习是在 20 世纪 90 年代由 Gerald Tesauro（时间差异学习和 td-gammon，1995）的研究中引入的，他与 IBM 合作开发了一个在 1992 年学习玩西洋双陆棋的智能体，以及 Long-Ji Lin（使用神经网络的机器人强化学习，1993）。

• 自 2013 年以来，研究人员提出了许多著名的方法来学习使用深度 RL 来解决复杂任务，例如用于围棋游戏的AlphaGo （David Silver 等人，2016）、通过自我学习掌握围棋、国际象棋和将棋的AlphaZero 。玩（David Silver 等人，2017-2018），用于 Dota 2 的具有自我对弈功能的OpenAI Five（OpenAI，2019），以及用于星际争霸 2 的AlphaStar ，该算法使用具有经验回放、自模仿学习和策略的演员批评算法蒸馏（Oriol Vinyals 等，2019）。此外，还有其他实验，例如Electronic Arts/DICE 工程师针对《战地 1》进行的深度强化学习。

• 视频游戏在深度强化学习研究中流行的原因之一是，与现实世界的实验（例如使用遥控直升机的强化学习）不同（Pieter Abbeel 等，2006），虚拟模拟可以提供更安全的测试环境。

• 如果您有兴趣了解深度强化学习对神经科学等其他领域的影响，可以参考Matthew Botvinick等人 (2020)的论文。

如何在 Jupyter 笔记本中设置视频播放

• 如果您使用Binder（一种基于 Jupyter 笔记本的免费工具），您可以设置 Docker 映像并将freeglut3-dev、xvfb、 和添加x11-utils到apt.txt配置文件中以安装初始依赖项。然后，在binder/environment.yml下方channels添加gym以及pyvirtualdisplay您可能需要的任何其他内容，例如python=3.7、pip和jupyterlab。查看以下帖子以获取更多信息。

• 如果您使用Google Colaboratory（另一个免费的基于 Jupyter 笔记本的工具），您可以安装和设置X 虚拟帧缓冲区/ Xvfb、X11、FFmpeg、PyVirtualDisplay、PyOpenGL和其他依赖项来启用游戏环境的视频播放，如下所示下面进一步描述。

1. 如果您使用的是 Google Colaboratory，请在笔记本单元格中运行以下命令以帮助播放视频：

   # Install Xvfb and X11 dependencies.
   !apt-get install -y xvfb x11-utils > /dev/null 2>&1
   # To work with videos, install FFmpeg.
   !apt-get install -y ffmpeg > /dev/null 2>&1
   # Install PyVirtualDisplay for visual feedback and other libraries/dependencies.
   !pip install pyvirtualdisplay PyOpenGL PyOpenGL-accelerate > /dev/null 2>&1
   

2. 然后，添加以下 Python 代码：

   # Import the virtual display module.
   from pyvirtualdisplay import Display
   # Import ipythondisplay and HTML from IPython for image and video rendering.
   from IPython import display as ipythondisplay
   from IPython.display import HTML
   
   # Initialize the virtual buffer at 400x300 (adjustable size).
   # With Xvfb, you should set `visible=False`.
   display = Display(visible=False, size=(400, 300))
   display.start()
   
   # Check that no display is present.
   # If no displays are present, the expected output is `:0`.
   !echo $DISPLAY
   
   # Define a helper function to display videos in Jupyter notebooks:.
   # (Source: https://star-ai.github.io/Rendering-OpenAi-Gym-in-Colaboratory/)
   
   import sys
   import math
   import glob
   import io
   import base64
   
   def show_any_video(mp4video=0):
       mp4list = glob.glob('video/*.mp4')
       if len(mp4list) > 0:
           mp4 = mp4list[mp4video]
           video = io.open(mp4, 'r+b').read()
           encoded = base64.b64encode(video)
           ipythondisplay.display(HTML(data='''<video alt="test" autoplay
                                               loop controls style="height: 400px;">
                                               <source src="data:video/mp4;base64,{0}" type="video/mp4" />
                                               </video>'''.format(encoded.decode('ascii'))))
   
       else:
           print('Could not find the video!')
   
   

• 如果您想在 Jupyter Notebook 中查看最后（非常快）的游戏玩法并show_any_video()提前实现该功能，请在单元格中运行以下命令：

  show_any_video(-1)
  

• 如果您在 Linux 或 macOS 的本地环境中按照本教程中的说明进行操作，则可以将大部分代码添加到一个Python ( .py)文件中。然后，您可以在终端中运行 Gym 实验。要启用渲染，您可以按照OpenAI Gym 官方文档使用命令行界面（确保您已安装 Gym 和 Xvfb，如指南中所述）。python your-code.py