DQN-FlappyBird学习之算法思路+代码分析+python技巧

首先从上一节博文我们知道了关于如何通过shell脚本进行传递参数
在main文件中,我们看到在train的环节有以下代码:
if args.train:
model = BrainDQN(epsilon=args.init_e, mem_size=args.memory_size, cuda=args.cuda)
resume = not args.weight == ‘’
train_dqn(model, args, resume)
接下来我们来看看这些具体的函数是怎么运行的。

本文通过训练过程中用到的函数的顺序进行讲解

import

import sys
sys.path.append("game/")
import game.wrapped_flappy_bird as game
from BrainDQN import *
import shutil
import numpy as np
import random
import torch
import torch.nn as nn
import torch.optim as optim
from torch.autograd import Variable
import PIL.Image as Image

IMAGE_SIZE = (72, 128)

train_dqn

程序梳理:

1、首先是将best_time_step置0

def train_dqn(model, options, resume):
    best_time_step = 0.

2、然后判断是否利用之前未训练完的weight继续学习

    if resume:
        if options.weight is None:
            print ('when resume, you should give weight file name.')
            return
        print ('load previous model weight: {}'.format(options.weight))
        _, _, best_time_step = load_checkpoint(options.weight, model)

tips1:
1、这里options就是在main文件中的args,这里相当于直接传入参数类,然后可以自由选择在dqn中用到哪些参数。
2、’{}’.format(options.weight)),在字符串中传入参数

这里是首先将保存的参数加载到已经实例化好的model中,然后返回最优的步数,可以用于判断是否保存后面的参数。

3、实例化游戏

    flappyBird = game.GameState()

4、定义优化器和损失

    optimizer = optim.RMSprop(model.parameters(), lr=options.lr)
    ceriterion = nn.MSELoss()

model.parameters()是在model父类中定义的,可以直接调用,优化采取均方误差损失。

5、走出第一步

    action = [1, 0]
    o, r, terminal = flappyBird.frame_step(action)
    o = preprocess(o)
    model.set_initial_state()

第一步选择不点击屏幕,然后得到游戏的反馈,对图像进行预处理,得到第一张预处理的图片。初始化状态矩阵,形状为412872,现在元素都为0。

6、是否使用cuda加速

    if options.cuda:
        model = model.cuda()

7、开始的几步不训练

在游戏的开始100个环节,先不对网络进行训练,先积累训练样本。

    # in the first `OBSERVE` time steos, we dont train the model
    for i in range(options.observation):
        action = model.get_action_randomly()
        o, r, terminal = flappyBird.frame_step(action)
        o = preprocess(o)
        model.store_transition(o, action, r, terminal)

由于前100步用于探索环境,不训练,因此这里的动作是随机选择的,与状态策略无关。
然后将每一步的图片(状态),动作和奖励储存。

动作选择函数定义
def get_action_randomly(self):
action = np.zeros(self.actions, dtype=np.float32)
#action_index = random.randrange(self.actions)
action_index = 0 if random.random() < 0.8 else 1
action[action_index] = 1
return action
每次执行函数先定义1*2的全0数组,然后以0.8的概率选择不点击屏幕。

储存函数定义
def store_transition(self, o_next, action, reward, terminal):
next_state = np.append(self.current_state[1:,:,:], o_next.reshape((1,)+o_next.shape), axis=0)
self.replay_memory.append((self.current_state, action, reward, next_state, terminal))
if len(self.replay_memory) > self.mem_size:
self.replay_memory.popleft()
if not terminal:
self.current_state = next_state
else:
self.set_initial_state()
tips2:
1、传入参数有下一步的状态,当前的动作,得到的奖励以及是否终止
2、self.current_state[1:,:,:]在这里相当于self.current_state[1:,]即去掉最外面一维的第一个元素。因为添加的方式是append,从末尾添加,因此这种方式就是去掉时间最早的经验。
3、o_next.reshape((1,)+o_next.shape )得到的形状是112772。
4、这里要理解经验池中的每一个state都是4个观测的组合。添加仅经验池的也是4个state的组合,而不是当前的state
5、经验池是固定大小的,如果超出self.replay_memory.popleft()
6、如果当前到达的是终点,就返回空的数组,相当于初始化下一次的状态。

8、遍历options.max_episode轮

这个函数是主要的实现算法的部分
part1

    for episode in range(options.max_episode):
        model.time_step = 0
        model.set_train()
        total_reward = 0.
        # begin an episode!
        while True:
            optimizer.zero_grad()
            action = model.get_action()
            o_next, r, terminal = flappyBird.frame_step(action)
            total_reward += options.gamma**model.time_step * r
            o_next = preprocess(o_next)
            model.store_transition(o_next, action, r, terminal)
            model.increase_time_step()
            # Step 1: obtain random minibatch from replay memory
            minibatch = random.sample(model.replay_memory, options.batch_size)
            state_batch = np.array([data[0] for data in minibatch])
            action_batch = np.array([data[1] for data in minibatch])
            reward_batch = np.array([data[2] for data in minibatch])
            next_state_batch = np.array([data[3] for data in minibatch])
            state_batch_var = Variable(torch.from_numpy(state_batch))
            with torch.no_grad():
                next_state_batch_var = Variable(torch.from_numpy(next_state_batch))
            if options.cuda:
                state_batch_var = state_batch_var.cuda()
                next_state_batch_var = next_state_batch_var.cuda()
            # Step 2: calculate y
            q_value_next = model.forward(next_state_batch_var)

            q_value = model.forward(state_batch_var)

            y = reward_batch.astype(np.float32)
            max_q, _ = torch.max(q_value_next, dim=1)

            for i in range(options.batch_size):
                if not minibatch[i][4]:
                    y[i] += options.gamma*max_q[[i][0]].item()

            y = Variable(torch.from_numpy(y))
            action_batch_var = Variable(torch.from_numpy(action_batch))
            if options.cuda:
                y = y.cuda()
                action_batch_var = action_batch_var.cuda()
            q_value = torch.sum(torch.mul(action_batch_var, q_value), dim=1)

            loss = ceriterion(q_value, y)
            loss.backward()

            optimizer.step()
            # when the bird dies, the episode ends
            if terminal:
                break

        print ('episode: {}, epsilon: {:.4f}, max time step: {}, total reward: {:.6f}'.format(
                episode, model.epsilon, model.time_step, total_reward))

        if model.epsilon > options.final_e:
            delta = (options.init_e - options.final_e)/options.exploration
            model.epsilon -= delta

        if episode % 100 == 0:
            ave_time = test_dqn(model, episode)

        if ave_time > best_time_step:
            best_time_step = ave_time
            save_checkpoint({
                'episode': episode,
                'epsilon': model.epsilon,
                'state_dict': model.state_dict(),
                'best_time_step': best_time_step,
                 }, True, 'checkpoint-episode-%d.pth.tar' %episode)
        elif episode % options.save_checkpoint_freq == 0:
            save_checkpoint({
                'episode:': episode,
                'epsilon': model.epsilon,
                'state_dict': model.state_dict(),
                'time_step': ave_time,
                 }, False, 'checkpoint-episode-%d.pth.tar' %episode)
        else:
            continue
        print ('save checkpoint, episode={}, ave time step={:.2f}'.format(
                 episode, ave_time))

首先在每一轮(直到游戏结束)开始的时候将当前步数置0,然后通过调用model.set_train()将train标志位设置为True。用与下面选择动作的时候确定选择最优动作(test)还是根据ε策略选择。将总奖励置零。

        model.time_step = 0
        model.set_train()
        total_reward = 0.
        # begin an episode!

然后是进入持续动作空间(while True),在这个while循环中
首先进行游戏,得到奖励,存储变量。

            optimizer.zero_grad()
            action = model.get_action()
            o_next, r, terminal = flappyBird.frame_step(action)
            total_reward += options.gamma**model.time_step * r
            o_next = preprocess(o_next)
            model.store_transition(o_next, action, r, terminal)
            model.increase_time_step()

tips3:
optimizer.zero_grad()的作用是将梯度置零,这样在下一次进行训练的时候不会出错

minibatch = random.sample(model.replay_memory, options.batch_size)
state_batch = np.array([data[0] for data in minibatch])
action_batch = np.array([data[1] for data in minibatch])
reward_batch = np.array([data[2] for data in minibatch])
next_state_batch = np.array([data[3] for data in minibatch])

tips4
random.sample可以依据数据库的格式,抽取固定数量的样本
根据奖励状态等在经验池中位置提取批量的状态,动作,奖励,下一状态。

将当前状态(图片)变成一个tensor,并且下一状态的也变成一个tensor,但是却不涉及微分求导。

            state_batch_var = Variable(torch.from_numpy(state_batch))
            with torch.no_grad():
                next_state_batch_var = Variable(torch.from_numpy(next_state_batch))

这里也有一个cuda的加速判断

            if options.cuda:
                state_batch_var = state_batch_var.cuda()
                next_state_batch_var = next_state_batch_var.cuda()

从这一步往上,我们完成了行动一步,放入经验池,取经验,将状态设为可自动求微分的准备工作。
part2
首先将两步(图像)状态作为输入传入网络,计算得到输出(2维)

            q_value_next = model.forward(next_state_batch_var)
            q_value = model.forward(state_batch_var)

def createQNetwork(self):
self.conv1 = nn.Conv2d(4, 32, kernel_size=8, stride=4, padding=2)
self.relu1 = nn.ReLU(inplace=True)
self.conv2 = nn.Conv2d(32, 64, kernel_size=4, stride=2, padding=1)
self.relu2 = nn.ReLU(inplace=True)
self.map_size = (64, 16, 9)
self.fc1 = nn.Linear(self.map_size[0]*self.map_size[1]*self.map_size[2], 256)
self.relu3 = nn.ReLU(inplace=True)
self.fc2 = nn.Linear(256, self.actions)
经过两层卷积两层全连接,其中3个relu激活

def get_q_value(self, o):
out = self.conv1(o)
out = self.relu1(out)
out = self.conv2(out)
out = self.relu2(out)
out = out.view(out.size()[0], -1)
out = self.fc1(out)
out = self.relu3(out)
out = self.fc2(out)
return out
tips5
1、out.view的作用是将多维数据平铺为一维
2、x = a.view(a.size(0), -1)等价于x = x.view(x.size()[0], -1)

def forward(self, o):
q = self.get_q_value(o)
return q

然后将奖励的批量设置为如下格式,并命名为y

            y = reward_batch.astype(np.float32)

在上一步得到q_next值以后(二维输出),然后取其中的最大值

            max_q, _ = torch.max(q_value_next, dim=1)

对于batch中的每个样本,计算r+γmaxq(s’,a),即target

            for i in range(options.batch_size):
                if not minibatch[i][4]:
                    y[i] += options.gamma*max_q[[i][0]].item()

tips6:
因为由存储函数的定义可知,经验池中的样本由五个元素组成,最后一个是是否为终止状态,因此这里的意思是,只要不是终止状态,TDtarget都会加上后面哪一项,众所周知,在结束状态的价值函数等于0。

然后这值y为Variable

            y = Variable(torch.from_numpy(y))

设置action_batch为Variable

            action_batch_var = Variable(torch.from_numpy(action_batch))

设置这y和action_batch_var的原因是,y需要传入pytorch的损失中,action需要使用torch的mul函数。

一个cuda的判断

            if options.cuda:
                y = y.cuda()
                action_batch_var = action_batch_var.cuda()

因为q是关于动作的,但是这里通过神经网络得到的是两个值,因此需要确定当前的动作是哪个,这里的加和是关于mul的,不是关于所有样本的。

            q_value = torch.sum(torch.mul(action_batch_var, q_value), dim=1)

最后是关于损失

            loss = ceriterion(q_value, y)
            loss.backward()

最后优化

            optimizer.step()
            if terminal:
                break

9、每次while结束输出

        print ('episode: {}, epsilon: {:.4f}, max time step: {}, total reward: {:.6f}'.format(
                episode, model.epsilon, model.time_step, total_reward))

tips7:
1、{:.4f}表示4位浮点数,同时可以提供多个输入
2、step表示进行了多久,总奖励与实际游戏给出的奖励和时间步都有关

10、epsilon逐步减小

        if model.epsilon > options.final_e:
            delta = (options.init_e - options.final_e)/options.exploration
            model.epsilon -= delta

在这个程序中
final_epsilon=0.1
exploration=50000
initial_epsilon=1.
就是说这是一个常数,每次减小很小
由下图可知,在50000步的时候,epsilon已经到达0.1
在这里插入图片描述

11、每遍历100次就进行一次测试,并储存在测试中进行的平均步数(步数越高越好)

        if episode % 100 == 0:
            ave_time = test_dqn(model, episode)

def test_dqn(model, episode):
model.set_eval()
ave_time = 0.
for test_case in range(5):
model.time_step = 0
flappyBird = game.GameState()
o, r, terminal = flappyBird.frame_step([1, 0])
o = preprocess(o)
model.set_initial_state()
while True:
action = model.get_optim_action()
o, r, terminal = flappyBird.frame_step(action)
if terminal:
break
o = preprocess(o)
model.current_state = np.append(model.current_state[1:,:,:], o.reshape((1,)+o.shape), axis=0)
model.increase_time_step()
ave_time += model.time_step
ave_time /= 5
print (‘testing: episode: {}, average time: {}’.format(episode, ave_time))
return ave_time
首先设置model.set_eval,这一步的作用是将train标志位置0,这样在提取动作的时候,就会选择最优动作。
然后运行5个回合,取平均,游戏中的初始化需要做的是,开始游戏,根据一个固定的动作获取状态奖励,预处理数据,再初始化当前训练数据(4个叠在一起)
在每一个回合中,首先选取最优动作,然后获得奖励,状态等,然后预处理,更新状态
注意这里不需要加入经验池,然后增加步数。

tips9:
在程序中我们一共用到三个动作选择函数,分别是一开始的随机选择动作100次,然后是在train中使用epilison策略选取,最后是在test中使用最优策略选取。这里的策略指的是根据Q值大小进行选择。

(1)
def get_action(self):
if self.train and random.random() <= self.epsilon:
return self.get_action_randomly()
return self.get_optim_action()
tips8:
if里面的returen是退出整个函数的意思

(2)
def get_optim_action(self):
state = self.current_state
with torch.no_grad():
state_var = Variable(torch.from_numpy(state)).unsqueeze(0)
if self.use_cuda:
state_var = state_var.cuda()
q_value = self.forward(state_var)
_, action_index = torch.max(q_value, dim=1)
action_index = action_index[[0][0]].item()
action = np.zeros(self.actions, dtype=np.float32)
action[action_index] = 1
return action
在测试中我们选择的时最优动作
在这个函数中,首先获取当前状态,这里的状态就是4个图片的叠加。并且在train或者test的开头都会init一下。
然后由于是选择最优动作,因此需要判断当前状态下哪个动作对应的值最大。这里的current就是上一步储存的下一步的值。
然后就是计算q值,选取最大动作索引。
tips10:
1、由于使用神经网络时传入的数据必须是tensor,同时因为在训练过程中不需要求导,因此设置no_grad()。
2、tourch.max函数返回每一行最大值和索引,这里我们只需要索引。索引是字典形式,首先转换为元组,然后取值
3、unsqueeze(0)表示增添一维度,因为pytorch输入的第一维一定是样本数。
python中的unsqueeze()和squeeze()函数

(3)
def get_action_randomly(self):
action = np.zeros(self.actions, dtype=np.float32)
#action_index = random.randrange(self.actions)
action_index = 0 if random.random() < 0.8 else 1
action[action_index] = 1
return action

12、保存数据

(1)当测试中发现运行时间比上一次测试时步数长的时后,更新最优时间(长),并保存参数
(2)当程序中固定每隔一段时间保存一次参数

        if model.epsilon > options.final_e:
            delta = (options.init_e - options.final_e)/options.exploration
            model.epsilon -= delta

        if episode % 100 == 0:
            ave_time = test_dqn(model, episode)

        if ave_time > best_time_step:
            best_time_step = ave_time
            save_checkpoint({
                'episode': episode,
                'epsilon': model.epsilon,
                'state_dict': model.state_dict(),
                'best_time_step': best_time_step,
                 }, True, 'checkpoint-episode-%d.pth.tar' %episode)
        elif episode % options.save_checkpoint_freq == 0:
            save_checkpoint({
                'episode:': episode,
                'epsilon': model.epsilon,
                'state_dict': model.state_dict(),
                'time_step': ave_time,
                 }, False, 'checkpoint-episode-%d.pth.tar' %episode)
        else:
            continue
        print ('save checkpoint, episode={}, ave time step={:.2f}'.format(
                 episode, ave_time))

tips11:
定义:
def save_checkpoint(state, is_best, filename=‘checkpoint.pth.tar’):
torch.save(state, filename)
if is_best:
shutil.copyfile(filename, ‘model_best.pth.tar’)
应用:
save_checkpoint({
‘episode’: episode,
‘epsilon’: model.epsilon,
‘state_dict’: model.state_dict(),
‘best_time_step’: best_time_step,
}, True, ‘checkpoint-episode-%d.pth.tar’ %episode)
1、这种保存方法只是保存参数model.state_dict(),但是如果用load.save()则可以保存整个神经网络的模型和参数,别人用的话只需要model = load…就可以
2、保存的其他参数比如best_time_step可用于中途离开,后来继续训练用,其他的我想应该也是可以继续用的,但是在这个代码中在训练中只用到best_time_step.

tips12:
接下来是一个在play中的一个技巧
print ('load pretrained model file: ’ + model_file_name)因为都是字符串,因此可以直接加减,不需要使用format

论文

在论文中
在这里插入图片描述
分析可发现,代码实现的思路和论文一样,在卷积中利用了有部分重叠的卷积。

代码流程

在这里插入图片描述

相关推荐
©️2020 CSDN 皮肤主题: 精致技术 设计师:CSDN官方博客 返回首页