（零基础可以看懂）深度强化学习之DQN类算法之第2篇-2015年Nature版本的DQN（含代码）-《强化学习系列专栏第5篇》

背景

    这一篇是DeepMind团队经过对2013版本的DQN改造后，在Nature上发表的，也就是业界称的Nature版本的DQN。这个模型和2013版本的区别是，该版本使用了两个网络，一个网络叫main network，另一个网络叫target network。

论文原文链接

《Human-level Control Through Deep Reinforcement Learning》

介绍

    读懂这篇论文还需要知道一些前置的知识，前置的知识我已经讲解过了，在我的博客上，我附一下链接。有一些基础的人，只需要看第4篇就可以了。

第1篇：（零基础可以看懂）强化学习中的动态规划（贝尔曼方程）（含代码）-《强化学习系列专栏第1篇》
第2篇：（零基础可以看懂）强化学习中的蒙特卡罗应用（贝尔曼方程）（含代码）-《强化学习系列专栏第2篇》
第3篇：（零基础可以看懂）强化学习中的时间差分算法（含代码）-《强化学习系列专栏第3篇》
第4篇：（零基础可以看懂）深度强化学习之DQN类算法之第1篇-2013年NeurIPS版本的DQN（含代码）-《强化学习系列专栏第4篇》

模型关键部分解释

    我们首先把算法的伪代码放上来，并且将2013版本的DQN的伪代码也放上来，来对比看下有什么区别。

2015版本的DQN

2013版本的DQN

仔细观察，可以看出以下区别：
①2015的DQN中的
$$otherwiseselect{a}_t=argma{x}_{a}Q(\Phi (s_t),a;\theta )$$
这句话中的Q指的是action-value network，也就是main network。

②2015的DQN中的公式
y i = { r j r j + γ m a x a ′ Q ^ ( Φ j + 1 , a ′ ; θ ) y_i=

$$\begin{cases} r_j \\ r_j+γmax_{a^\prime}\hat{Q}(Φ_{j+1},a^\prime;θ) \end{cases}$$ yi​={rj​rj​+γmaxa′​Q^​(Φj+1​,a′;θ)​
中的$\hat{Q}$指的是target action-value network，也就是target network。这一点与2013的DQN中的公式不同。

③2015的DQN中还多了一个步骤
$$EveryCstepsreset\hat{Q}=Q$$
这其实就相当于是，我们在计算$y_i$的值的时候，用的是target network，然后实际上被训练的是main network，然后每过C steps，target network的参数就会被“赋值”为main network的参数，也就是会被update一次。论文中，C设置为10000。
④上面③这个改进也是2015版DQN相较于2013版DQN的主要改进，这样做的好处是，在训练时，模型更容易往稳定的方向去迭代。因为2013版的DQN就存在训练时不稳定的问题，本人在训练2013版的DQN时就存在这个问题，训练了好久，reward也没有增加，这导致一度我以为是我代码有问题。后来在训练2015版的DQN时，我发现也有这种问题，只不过2015版的DQN好一点。

代码跑的结果展示

    这里，我是选择了玩Seaquest这个游戏，在gym里面，名称为“Seaquest-v0”。游戏过程的截图及视频如下。

截图

    可以看到，大部分时间潜艇是在画面底部晃动来得分的。下面看一下reward的滚动平均的图

reward及其滚动均值

下面看一下loss的滚动平均的图

    通过观察上面的reward变化以及loss变化，我们可以知道，loss是不会收敛的，因为训练的数据是不断在变化的，并不是像普通的监督学习那样样本是固定不变的。因此每一次前向传播的时候，数据极有可能是模型未曾见过的。
    同时，reward随着训练不断的增加，其不同幕的平均值是在不断增加的。也证明了该模型确实是有效的。但从未做滚动平均的reward的图上看，可以知道，reward其实波动是大的。
    总体来说，如果让计算机随机玩游戏，那么其reward的平均值大约在90/幕，但是经过训练一段时间后，reward的平均值可以达到590/幕，我训练到了590/幕，随着训练时间的增加，该数值会不断的增加。但由于模型本身鲁棒性就存在缺陷，所以也有可能reward会陷入不下降也不上升的情况。模型的这个缺陷我认为和exploration有关，从上面的视频可以看出，模型发现了只要在游戏下方不断的晃动开枪，就可以获得比较高的收益，所以大部分时间并没有跑到游戏上方去获取分数。这点可以通过增加exploration的rate来打破这种陷入“局部最优”的情况。也是由于这种问题，导致我在跑2013版的DQN模型的时候，玩“Pong”这个游戏时，reward一直升不上去。

代码

#encoding=utf-8
'''
Author: Haitaifantuan
Create Date: 2020-09-27 23:23:52
Author Email: 47970915@qq.com
Description: Should you have any question, do not hesitate to contact me via E-mail.
'''
import gym
import torch.nn as nn
import torch
from torchvision import transforms
import atari_py
import random
import time
from PIL import Image
import matplotlib.pyplot as plt
from collections import deque
import copy
import os


class Preprocessing(nn.Module):
    def __init__(self):
        super(Preprocessing, self).__init__()

        self.preprocessing = transforms.Compose([
            # 按照论文步骤
            # 先转换为灰度图
            transforms.Grayscale(1),
            # 再下采样到110*84的大小
            transforms.Resize((110, 84)),
            # 转换为Tensor()输入到网络
            transforms.ToTensor()
            ]
        )


    def forward(self, input):
        # 由于传进来是torch.Tensor()
        # 所以我们要将其转换为PIL.Image才能预处理
        input = Image.fromarray(input)
        # 最后输出的就是论文所说的84*84的灰度图像了
        output = self.preprocessing(input)  # 这个时候output是[1, 84, 84]
        # 将多余的维度压缩掉，最后返回的是[84, 84]的形状
        output = torch.squeeze(output)
        # 然后再裁剪到84*84的大小的游戏区域
        output = output[17:101, :]  # 这个区域是游戏的区域
        # plt.imshow(output, cmap='gray')
        # plt.show()
        return output


class Deep_Q_Network(nn.Module):
    def __init__(self, action_nums):
        super(Deep_Q_Network, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(4, 16, (8, 8), 4),
            nn.ReLU(),  # 论文中使用的不一定是这个激活函数，这里是为了简化使用ReLU
            nn.Conv2d(16, 32, (4, 4), 2),
            nn.ReLU()  # 论文中使用的不一定是这个激活函数，这里是为了简化使用ReLU
        )

        self.classifier = nn.Sequential(
            nn.Linear(2592, 256),
            nn.Linear(256, action_nums)
        )

    def forward(self, input):
        output = self.features(input)
        output = output.view(-1, 2592)
        output = self.classifier(output)
        output = torch.squeeze(output)
        return output

    def initialization(self):
        for m in self.modules():
            if isinstance(m, nn.Linear):
                nn.init.kaiming_normal_(m.weight.data)
            if isinstance(m, nn.Linear):
                nn.init.kaiming_normal_(m.weight.data)


class Agent(object):
    def __init__(self):
        # 模型保存的路径
        self.model_path = './2015_Nature_DQN_cpu_trained_model_save_reward_loss'
        if not os.path.exists(self.model_path):
            os.mkdir(self.model_path)
        self.save_model_path = self.model_path + '/model'

        self.lr = 0.00001

        # 我们玩Seaquest游戏，这里搭建下环境
        self.env = gym.make('Seaquest-v0')
        self.env = self.env.unwrapped
        # 这个是游戏的valid的动作
        self.action_space = self.env.action_space.n
        self.action_nums = self.env.action_space.n
        # 构建图像预处理对象
        self.preprocessing = Preprocessing()
        # 构建action-value网络，和target action-value网络
        self.a_v_net = Deep_Q_Network(self.action_nums)
        self.target_a_v_net = Deep_Q_Network(self.action_nums)

        # 初始化网络
        if os.path.exists(self.save_model_path):
            state_dict = torch.load(self.save_model_path)
            self.a_v_net.load_state_dict(state_dict)
            self.target_a_v_net.load_state_dict(state_dict)
            print("从已训练好的模型中加载action-value网络和target action-value网络成功")
        else:
            self.a_v_net.initialization()
            self.target_a_v_net.initialization()
            print("初始化action-value网络和target action-value网络所有参数成功")

        # 构建action-value 网络的损失函数
        self.loss_func = nn.MSELoss()
        # 构建优化器
        self.opti = torch.optim.SGD(self.a_v_net.parameters(), lr=self.lr, momentum=0.9)
        # 每次训练的样本数量，论文中是32
        self.batch_size = 32
        # 创建一个缓存，超过大小后，最新的放进去，老的扔掉
        # self.replay_memory_size = 1000000
        self.replay_memory_size = 500000  # 30000的话，2080Ti显存11G不够  10万需要20个G内存左右
        self.replay_memory = deque()
        # 当memory_size达到多少后，开始训练
        self.begin_to_train_memory_size = 50000

        self.alpha = 0.9
        self.gamma = 0.99
        self.init_epsilon = 0.1  # 论文为1
        # self.init_epsilon = 0.9
        self.final_epsilon = 0.1  # 论文为0.1
        # self.final_epsilon = 0.01
        self.epsilon_decay_frames = 1000000  # 论文1000000
        # self.epsilon_decay_frames = 100000

        self.train_times = 0
        self.every_C_steps = 10000

        # 论文中是每4帧，agent进行一次动作的选择。
        self.select_action_every_k_time = 4

        # 记录reward变化的变量
        self.reward_change = []
        # 记录loss变化的变量
        self.loss_change = []

    def four_img_list_to_Q_net_input(self, four_img_list):
        stacked = torch.stack(list(four_img_list))
        return stacked

    def generate_initial_4_frames(self, current_state_single_frame):
        '''
        由于环境一开始，four_img_list的长度是小于4的
        因此我们需要让其长度达到4后，再继续后面的记录操作
        在前4步，我们都使用模型选择动作
        :param current_state_single_frame:
        :return: 返回一个队列，里面存放了第1、2、3、4帧游戏画面的对应的Tensor数值
        '''
        four_img_list = deque()
        # 由于一开始并没有4张图片可以使用
        # 因此，我们根据当前的状态，复制出另外3张图片
        # 然后随着step的进行，我们一张图片一张图片的放进去
        four_img_list.extend([current_state_single_frame, current_state_single_frame,
                              current_state_single_frame, current_state_single_frame])

        for _ in range(3):
            # 渲染环境
            self.env.render()
            # 这里将4帧图片变成4个通道放到网络里
            current_state_4_frames_stacked_result = self.four_img_list_to_Q_net_input(four_img_list)
            # 放到网络里需要再添加一个Batch_size部分的维度
            current_state_4_frames_stacked_result = torch.unsqueeze(current_state_4_frames_stacked_result,dim=0)
            action_value = self.a_v_net(current_state_4_frames_stacked_result)
            action = torch.argmax(action_value)
            next_state, reward, done, info = self.env.step(action)
            next_state_to_tensor = self.preprocessing(next_state)

            four_img_list.append(next_state_to_tensor)
            four_img_list.popleft()

        return four_img_list

    def train(self):
        # 原始论文：如果达到了replay_memory的最大值，那就开始从replay_memory中随机选取样本进行训练
        # if len(self.replay_memory) > (self.replay_memory_size - 1):
        if len(self.replay_memory) > self.begin_to_train_memory_size:

            batch_data = random.choices(self.replay_memory, k=32)

            # 拿到训练数据后，将他们进行解包
            current_state_4_frames_stacked_result_list = [each[0] for each in batch_data]
            current_state_action_list = torch.LongTensor([[each[1]] for each in batch_data])
            reward_list = torch.FloatTensor([[each[2]] for each in batch_data])
            next_state_4_frames_stacked_result_list = [each[3] for each in batch_data]
            done_list = [[each[4]] for each in batch_data]

            # 将训练数据放到模型里进行前向传播
            y_pre = self.a_v_net(torch.stack(current_state_4_frames_stacked_result_list).squeeze()).gather(dim=1, index=current_state_action_list)

            # 根据公式，构建标签值
            q_net_result = self.target_a_v_net(torch.stack(next_state_4_frames_stacked_result_list, dim=0)).detach()
            y_target = reward_list + self.gamma * torch.max(q_net_result, dim=1)[0].reshape(self.batch_size, -1)

            self.loss = self.loss_func(y_pre, y_target)
            # loss = loss.to('cpu')
            self.opti.zero_grad()
            self.loss.backward()
            self.opti.step()
            self.train_times += 1

    def close_env(self):
        self.env.close()

    def save_model(self):
        torch.save(self.a_v_net.state_dict(), self.save_model_path)

    def fire_in_the_hole(self):
        self.steps_count = 0
        self.current_epsilon = self.init_epsilon
        self.begin_time = time.time()
        for self.episode in range(100000):
            # 一个episode结束后，重新设置下环境，返回到随机的一个初始状态
            current_state_single_frame = self.env.reset()
            # 将current_state()预处理一下然后转换为Tensor
            current_state = self.preprocessing(current_state_single_frame)

            # 这个方法返回的four_img_list里面就存放了第1、2、3、4帧画面的Tensor()形式
            four_img_list = self.generate_initial_4_frames(current_state)
            current_state_4_frames_stacked_result = self.four_img_list_to_Q_net_input(four_img_list)

            # 记录一下当前这一盘总的reward
            self.current_episode_reward = 0
            self.select_action_count = 0
            while True:
                # 渲染环境
                self.env.render()

                # 论文每4帧才根据ε-greedy方法做一个动作
                # 其他3帧时间的动作选取上一轮选择的动作
                if self.select_action_count == 0 or self.select_action_count == self.select_action_every_k_time:
                    # 根据ε-greedy方法，走一步，看看
                    if random.random() < self.current_epsilon:
                        current_state_action = self.env.action_space.sample()
                    else:
                        # 根据Q函数找到最优的动作
                        # 放到网络里需要再添加一个Batch_size部分的维度
                        action_value = self.a_v_net(torch.unsqueeze(current_state_4_frames_stacked_result, dim=0))
                        current_state_action = torch.argmax(action_value)

                    self.select_action_count = 0

                next_state, reward, done, info = self.env.step(current_state_action)
                next_state_to_tensor = self.preprocessing(next_state)

                self.current_episode_reward += reward

                four_img_list.append(next_state_to_tensor)
                four_img_list.popleft()

                next_state_4_frames_stacked_result = self.four_img_list_to_Q_net_input(four_img_list)

                # （将当前的状态以及前三幅图片组成的图片，当前的行为，当前获得的奖励，下一个状态，游戏是否结束）添加到replay_memory中
                self.replay_memory.append((current_state_4_frames_stacked_result, current_state_action,
                                      reward, next_state_4_frames_stacked_result, done))
                if len(self.replay_memory) > self.replay_memory_size:
                    self.replay_memory.popleft()

                # 判断当前这一盘游戏是否结束
                if done:
                    self.end_time = time.time()
                    self.total_seconds = self.end_time - self.begin_time
                    self.day = int(self.total_seconds / (60 * 60 * 24))
                    self.hour = int(self.total_seconds / (60 * 60) - self.day * 24)
                    self.minute = int(self.total_seconds/60 - self.day*24*60 - self.hour*60)

                    if len(self.replay_memory) < self.begin_to_train_memory_size:
                        self.loss = torch.tensor(0)

                    break

                current_state_4_frames_stacked_result = next_state_4_frames_stacked_result
                self.select_action_count += 1


                self.steps_count += 1
                if self.steps_count <= self.epsilon_decay_frames and len(self.replay_memory) > self.begin_to_train_memory_size:
                    self.current_epsilon = self.init_epsilon - (self.init_epsilon - self.final_epsilon) * (self.steps_count-self.begin_to_train_memory_size) / self.epsilon_decay_frames

                # 执行训练网络的操作，里面会判断reply_memory的长度是否达到最大值了
                self.train()

                # 每self.every_C_steps步，更新将target_action_value网络的参数更新为action_value网络的参数
                if self.steps_count % self.every_C_steps == 0:
                    self.update_target_network()

            self.reward_change.append(self.current_episode_reward)
            self.loss_change.append(self.loss.data.item())

            print(
                "当前已训练{}天-{}小时-{}分钟===当前为第{}个Episode===当前episode共获得{}reward===总共已训练{}次===当前的loss为：{}===当前的epsilon值为：{}===当前reply_memory的长度为：{}".format(
                    self.day, self.hour, self.minute, self.episode+1, self.current_episode_reward, self.train_times, self.loss.data.item(),
                    self.current_epsilon, len(self.replay_memory)))

            if (self.episode + 1) % 10 == 0:
                # 保存模型
                self.save_model()
                # 将当前的self.reward_change列表保存下来，以覆盖的方式保存下来。
                with open(self.model_path+'/reward_change.txt', 'w', encoding='utf-8') as file:
                    file.write(str(self.reward_change))

                # 将当前的self.loss_change保存下来
                with open(self.model_path+'/loss_change.txt', 'w', encoding='utf-8') as file:
                    file.write(str(self.loss_change))

                # 打印出当前reward的图
                # plt.clf()
                # plt.plot(self.reward_change)
                # plt.draw()

        # 关闭游戏环境
        self.close_env()

    def update_target_network(self):
        self.target_a_v_net.load_state_dict(self.a_v_net.state_dict())



agent = Agent()
agent.fire_in_the_hole()


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333

代码复现、详细讲解及我的Github地址

完整代码地址：https://github.com/haitaifantuan/reinforcement_leanring