一、 获取并处理环境图像

本文所刨析的代码是“pytorch官网的DQN示例”（页面），用卷积层配合强化训练去学习小车立杆，所使用的环境是“小车立杆环境”（CartPole）（源码）。先剧透个悲观的结果，官网的这个示例，并不能解决小车问题。单好消息是，一个简单的改动，就可以让结果好很多。

小车立杆环境

先import 各种：

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
from IPython import display

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')

返回的这个env其实并非CartPole类本身，而是一个经过包装的环境：

env

>>

据说gym的多数环境都用TimeLimit（源码）包装了，以限制Epoch，就是step的次数限制，比如限定为200次。所以小车保持平衡200步后，就会失败。

env._max_episode_steps

200

用env.unwrapped可以得到原始的类，原始类想step多久就多久，不会200步后失败：

env.unwrapped

gym.envs.classic_control.cartpole.CartPoleEnv

环境 env 的 state 返回有4个变量：

env.state

array([0.00884328, 0.04488215, 0.00412898, 0.0128024 ])

它们分别是： (位置x，x加速度, 偏移角度theta, 角加速度)
初值值是4个[-0.05,0.05)的随机数:

from gym.utils import seeding
np_random, seed = seeding.np_random(None)
np_random.uniform(low=-0.05, high=0.05, size=(4,))

其实就是：numpy.random.RandomState.uniform(low=-0.05, high=0.05, size=(4,))。uniform distribution是均匀分布，各个数的出场次数都大致相等。对应的还有标准正态分布randn()，耿贝尔分布gumbel()等等。

这个环境的action有两个 : 0 和 1

env.action_space.n

2

env.step(0) ：小车向左
env.step(1) ：小车向右

小车的世界，就一条x轴，变量env.x_threshold里存放着小车坐标的最大值（=2.4），超过这个数值，世界结束，每step()一次，就会奖励 1，直到上次done为True。这样可以观看到小车移动动画：

env.reset()
for t in count(): 
    env.render()
    leftOrRight = random.randrange(env.action_space.n)
    _, reward, done, _ = env.step(leftOrRight)
    if done:
        break

有效世界的范围是：[-x_threshold, x_threshold]。有效世界的总长度为4.8：

world_width = env.x_threshold * 2

可以用env.render()来绘制出这个有效世界，对应的屏幕尺寸为高400、宽600：

400X600小车有效世界

世界坐标0，是屏幕的中点（300处），世界转屏幕系数为：

scale = screen_width / world_width

目前小车世界坐标x，可以用state[0]取出，这样通过scale，我们就可以计算出目前小车的屏幕坐标了。用 x * scale 得到屏幕坐标。

def get_cart_location(screen_width):
    #世界的总长度
    world_width = env.x_threshold * 2
    #世界转屏幕系数 : world_unit * scale = screen_unit
    scale = screen_width / world_width
    #世界中点在屏幕中间，所以偏移屏幕一半
    return int(env.state[0] * scale + screen_width / 2.0)

环境有个render函数，可以绘制当前场景。

1. env = gym.make() 每个env有自己的绘制窗口
2. 环境需要初始化env.reset()
3. env.render()会打开一个绘制窗口，绘制当前状态
4. 每次env.step()会更新状态
5. 用完以后需要调用env.close()关闭绘制窗口

render有一个参数，如果指定为 mode='rgb_array'时，不但弹窗渲染，还会返回当前窗口的像素值。整个开发过程，env自己的窗口都会一只存在，不用管它，每次render()它就会刷新，刷新完又“死”了。如果想随时关掉，可以用close()，下次render()会自动打开。

env.reset()
screen = env.render(mode='rgb_array')
screen.shape

(400, 600, 3)

把screen画出来看看：

plt.title('init state')
plt.imshow(screen)

小车大概在高40%（400X0.4=160）到80%（400X0.8=320）之间，所以整个画面可以剪切一下。剪切前先调整一下图片数据的顺序，现在是 400高X600宽X3色，调整为 3色X400X600，便于后续往网络里传输。numpy.transpose()函数，可以指定新的维度顺序，如(2，0，1) 就是将 维度 Y0，X1，C2调整为 C2，Y0，X1。 在pytorch里也有对应的函数，叫torch.Tensor.permute()。

def CutScreen(screen):
    Scr2 = screen.transpose((2, 0, 1))

再将高度按照160 - 320 截了：

    ScrCut = Scr2[:, int(screen_height*0.4):int(screen_height * 0.8)]

宽度只截取60%，左右各截30%：

    view_width = int(screen_width * 0.6)
    half_view_width = view_width // 2

如果小车左右还有30%的空间，则从小车位置前后截30%，如果小车太靠左则（或右则）没有30%的空间，则从最左侧（或最右侧）截取60%：

    cart_location = get_cart_location(screen_width)

    if cart_location < half_view_width:
        #太靠左了，左边没有30%空间，则从最左侧截取  [:half_view_width)
        slice_range = slice(view_width) 

    elif cart_location > (screen_width - half_view_width):
        #太靠右了，同理 [-half_view_width:)
        slice_range = slice(-view_width, None)

    else:
        #左右两侧都有空间，则截小车在中间 [-half_view_width: +half_view_width)
        slice_range = slice(cart_location - half_view_width, cart_location + half_view_width)
    
    #最后将图像X轴截了
    ScrCut = ScrCut[:, :, slice_range]
    return ScrCut

这样截取函数就好了，看下截取出来的图像。因为plt接受的是 (Y，X，颜色）所以我们还得把顺序临时调整回来：

CS = CutScreen(screen)
CS = CS.transpose((1, 2, 0))
plt.imshow(CS)

图像还是太大，需要把图片转换为高40的图片，可以用torchvision.transforms 的 Compose()和相关方法。
首先，目前为止，我们的screen都是numpy数组，需要用ToPILImage()转换为PIL，python自带图像格式，然后才可以用torchvision去处理图像，如 Resize()，最后记得转换为pytorch使用的tensor格式：

resize = T.Compose([T.ToPILImage(),
                    T.Resize(40, interpolation=Image.CUBIC),
                    T.ToTensor()])

接下来获取divice，以便pytorch可以使用显卡GPU：

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device

device(type='cuda')

定义我们的最终获取图像的处理过程：

def get_screen():
    screen = env.render(mode='rgb_array')
    screen = CutScreen(screen)

现在screen的格式是numpy数组，值范围[0, 255]，int8。而PIL接受的是float32的tensor，值范围[0.0, 1.0]，所以需要转换一下，可以这样：

    screen = torch.from_numpy(np.float32(screen)/255)

但是这样会引起内存数据拷贝。有一种inplace转换数据类型的方法：

y = x.view('float32')

这样y的内存和x是一致的，修改y，也会修改掉x。但是这个函数有个要求，就是数据必须是contiguous的，而我们的screen，不是：

ValueError: To change to a dtype of a different size, the array must be C-contiguous

screen.flags

C_CONTIGUOUS : False
F_CONTIGUOUS : False
……

如果想要数据contiguous，就要用到ascontiguousarray()函数，可以将内存按照C方式对齐，这样python就可以inplace转换数据类了。所以示例用了这个方法，不用进行内存拷贝而达到同样的效果：

    screen = np.ascontiguousarray(screen, dtype=np.float32) / 255
    screen = torch.from_numpy(screen)

最后放入resize。
因为pytorch.nn.Conv2d() 的输入形式为(N, C, Y, X)
N表示batch数
C表示channel数
Y，X表示图片的高和宽。
所以需要再增加一个N，最后再放入GPU：

    return resize(screen).unsqueeze(0).to(device)

unsqueeze()的作用是在n维之前增加一个维度，这里是在0维之前增加一个维度，增加前 screen尺寸是

torch.Size([3, 40, 90])

增加维度后，变为：

torch.Size([1, 3, 40, 90])

再来实际看一下这个，尺寸等比缩小，高为40的图片。想要plt get_screen()返回的东西，先要将其放回到CPU，然后去掉batch，调换方向把颜色放到后边，再转换为numpy：

scr = get_screen().cpu().squeeze(0).permute(1, 2, 0).numpy()

plt.figure()
plt.imshow(scr)
plt.title('Example extracted screen')
plt.show()

40 X 90

OK。图像处理完了，接下来要定义网络，训练网络了。
第二部分（连接）

二、 卷积网络和训练

接上回 处理环境图片。
python几处值得关注的用法（连接）

示例用卷积网络来训练动作输出：

def conv2d_size_out(size, kernel_size = 5, stride = 2):
    return (size - (kernel_size - 1) - 1) // stride  + 1

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)

        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)

    # Called with either one element to determine next action, or a batch
    # during optimization. Returns 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))

还是比较直白的：

• Conv 3通道 16通道
• Conv 16通道 32通道
• Conv 32通道 32通道
• Linear 512节点 2节点