PyTorch 1.0 中文官方教程：强化学习 (DQN) 教程

PyTorch 强化学习 01.强化学习（DQN）

pytorch,pytorch用来干嘛的,pytorch怎么读,pytorch环境搭建

本教程介绍如何使用PyTorch从OpenAI Gym中的 CartPole-v0 任务上训练一个Deep Q Learning (DQN) 代理。

代理人必须在两个动作之间做出决定 C 向左或向右移动推车 C 以使连接到它的杆保持直立。您可以在Gym?网站上找到官方排行榜，里面包含各种算法以及可视化。

当代理观察环境的当前状态并选择动作时，环境转换到新状态，并且还返回指示动作的后果的奖励。在此任务中，每增加一个时间步长的奖励为+1，如果杆落得太远或者推车距离中心超过2.4个单位，则环境终止。这意味着更好的表现场景将持续更长的时间，以及积累更大的回报。

CartPole任务的设计使得代理的输入是4个实际值，表示环境状态（位置，速度等）。然而，神经网络可以纯粹通过观察场景来解决任务，因此我们将使用以cart为中心的屏幕补丁作为输入。也因为如此，我们的结果与官方排行榜的结果无法直接比较 C 因为我们的任务要困难得多。而且不幸的是，这确实减慢了训练速度，因为我们必须渲染所有帧。

严格地说，我们将状态显示为当前屏幕补丁与前一个补丁之间的差异。这将允许代理从一个图像中考虑杆的速度。

首先，让我们导入所需的包。首先，我们需要gym来得到环境（使用pip install gym）。我们还将使用PyTorch中的以下内容：

神经网络(torch.nn)

优化(torch.optim)

自动分化（torch.autograd）

视觉任务的实用程序(torchvision)- 一个单独的包

import gym import math import random import numpy as np import matplotlib import matplotlib.pyplot as plt from collections import namedtuple from itertools import count from PIL import Image import torch import torch.nn as nn import torch.optim as optim import torch.nn.functional as F import torchvision.transforms as T env = gym.make('CartPole-v0').unwrapped # set up matplotlib is_ipython = 'inline' in matplotlib.get_backend() if is_ipython:     from IPython import display plt.ion() # if gpu is to be used device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

我们将使用经验重播记忆来训练我们的DQN。它存储代理观察到的转换，允许我们之后重用此数据。通过随机抽样，转换构建相关的一个批次。已经表明经验重播记忆极大地稳定并改善了DQN训练程序。

为此，我们需要两个阶段：

Transition：一个命名元组，表示我们环境中的单个转换。它实际上将（状态，动作）对映射到它们的（next_state，reward）结果，状态是屏幕差异图像，如稍后所述

ReplayMemory：有界大小的循环缓冲区，用于保存最近观察到的过渡。它还实现了一个.sample()方法，用于为训练选择随机batch 的转换。

Transition = namedtuple('Transition',                         ('state', 'action', 'next_state', 'reward')) class ReplayMemory(object):     def __init__(self, capacity):         self.capacity = capacity         self.memory = []         self.position = 0     def push(self, *args):         """Saves a transition."""         if len(self.memory) < self.capacity:             self.memory.append(None)         self.memory[self.position] = Transition(*args)         self.position = (self.position + 1) % self.capacity     def sample(self, batch_size):         return random.sample(self.memory, batch_size)     def __len__(self):         return len(self.memory)

现在，让我们定义我们的模型。但首先，让我们快速回顾一下DQN是什么。

我们的环境是确定性的，因此为了简单起见，这里给出的所有方程式也是确定性的。在强化学习文献中，它们还包含对环境中随机转变的期望。

class DQN(nn.Module):     def __init__(self, h, w, outputs):         super(DQN, self).__init__()         self.conv1 = nn.Conv2d(3, 16, kernel_size=5, stride=2)         self.bn1 = nn.BatchNorm2d(16)         self.conv2 = nn.Conv2d(16, 32, kernel_size=5, stride=2)         self.bn2 = nn.BatchNorm2d(32)         self.conv3 = nn.Conv2d(32, 32, kernel_size=5, stride=2)         self.bn3 = nn.BatchNorm2d(32)         # 线性输入连接的数量取决于conv2d层的输出，因此取决于输入图像的大小，因此请对其进行计算。         def conv2d_size_out(size, kernel_size = 5, stride = 2):             return (size - (kernel_size - 1) - 1) // stride  + 1         convw = conv2d_size_out(conv2d_size_out(conv2d_size_out(w)))         convh = conv2d_size_out(conv2d_size_out(conv2d_size_out(h)))         linear_input_size = convw * convh * 32         self.head = nn.Linear(linear_input_size, outputs)     # 使用一个元素调用以确定下一个操作，或在优化期间调用batch。返回tensor([[left0exp,right0exp]...]).     def forward(self, x):         x = F.relu(self.bn1(self.conv1(x)))         x = F.relu(self.bn2(self.conv2(x)))         x = F.relu(self.bn3(self.conv3(x)))         return self.head(x.view(x.size(0), -1))

下面的代码是用于从环境中提取和处理渲染图像的实用程序。它使用了torchvision软件包，可以轻松构成图像变换。运行单元后，它将显示一个提取的示例补丁。

resize = T.Compose([T.ToPILImage(),                     T.Resize(40, interpolation=Image.CUBIC),                     T.ToTensor()]) def get_cart_location(screen_width):     world_width = env.x_threshold * 2     scale = screen_width / world_width     return int(env.state[0] * scale + screen_width / 2.0)  # MIDDLE OF CART def get_screen():     # gym要求的返回屏幕是400x600x3，但有时更大，如800x1200x3。 将其转换为torch order（CHW）。     screen = env.render(mode='rgb_array').transpose((2, 0, 1))     # cart位于下半部分，因此不包括屏幕的顶部和底部     _, screen_height, screen_width = screen.shape     screen = screen[:, int(screen_height*0.4):int(screen_height * 0.8)]     view_width = int(screen_width * 0.6)     cart_location = get_cart_location(screen_width)     if cart_location < view_width // 2:         slice_range = slice(view_width)     elif cart_location > (screen_width - view_width // 2):         slice_range = slice(-view_width, None)     else:         slice_range = slice(cart_location - view_width // 2,                             cart_location + view_width // 2)     # 去掉边缘，使得我们有一个以cart为中心的方形图像     screen = screen[:, :, slice_range]     # 转换为float类型，重新缩放，转换为torch张量     # (this doesn't require a copy)     screen = np.ascontiguousarray(screen, dtype=np.float32) / 255     screen = torch.from_numpy(screen)     # 调整大小并添加batch维度（BCHW）     return resize(screen).unsqueeze(0).to(device) env.reset() plt.figure() plt.imshow(get_screen().cpu().squeeze(0).permute(1, 2, 0).numpy(),            interpolation='none') plt.title('Example extracted screen') plt.show()

这个单元实例化我们的模型及其优化器，并定义了一些实用程序：

select_action：将根据epsilon贪婪政策选择一项行动。简而言之，我们有时会使用我们的模型来选择动作，有时我们只会统一采样。选择随机操作的概率将从EPS_START开始，并将以指数方式向EPS_END衰减。EPS_DECAY控制衰减的速度

plot_durations：帮助绘制episodes的持续时间，以及过去100个episodes的平均值（官方评估中使用的度量）。该图将位于包含主要训练循环的单元下方，并将在每个episodes后更新。

BATCH_SIZE = 128 GAMMA = 0.999 EPS_START = 0.9 EPS_END = 0.05 EPS_DECAY = 200 TARGET_UPDATE = 10 # 获取屏幕大小，以便我们可以根据AI gym返回的形状正确初始化图层。 # 此时的典型尺寸接近3x40x90 # 这是get_screen（）中的限幅和缩小渲染缓冲区的结果 init_screen = get_screen() _, _, screen_height, screen_width = init_screen.shape # 从gym行动空间中获取行动数量 n_actions = env.action_space.n policy_net = DQN(screen_height, screen_width, n_actions).to(device) target_net = DQN(screen_height, screen_width, n_actions).to(device) target_net.load_state_dict(policy_net.state_dict()) target_net.eval() optimizer = optim.RMSprop(policy_net.parameters()) memory = ReplayMemory(10000) steps_done = 0 def select_action(state): global steps_done sample = random.random() eps_threshold = EPS_END + (EPS_START - EPS_END) * \ math.exp(-1. * steps_done / EPS_DECAY) steps_done += 1 if sample > eps_threshold: with torch.no_grad(): # t.max(1)将返回每行的最大列值。 # 最大结果的第二列是找到最大元素的索引，因此我们选择具有较