Press "Enter" to skip to content

用强化学习通关超级马里奥!

本站内容均来自兴趣收集,如不慎侵害的您的相关权益,请留言告知,我们将尽快删除.谢谢.

作者:肖遥,华中农业大学,Datawhale优秀学习者

 

 

 

DQN算法实践之速通超级马里奥

 

作为强化学习(Reinforce Learning,RL)的初学者,常常想将RL的理论应用于实际环境,以超级马里奥为例,当看着自己训练的AI逐渐适应环境,得分越来越高,到最后能完美躲避所有障碍,快速通关时,你肯定能体会到算法的魅力,成就感十足!本文不拘泥于DQN(Deep Q Learning Network)算法的深层原理,主要从代码实现的角度,为大家简洁直白的介绍DQN以及其改进方法,接着,基于Pytorch官方强化学习教程,应用改进后的DQN算法训练超级马里奥,并得到更为优秀的结果。

 

本文主要内容:

 

 

 

主要参考与项目地址:

 

算法理论参考:https://datawhalechina.github.io/easy-rl

 

算法代码参考:https://github.com/datawhalechina/easy-rl/tree/master/codes

 

书籍:Datawhale强化学习教程

 

Pytorch官方强化学习示例:

 

https://pytorch.org/tutorials/intermediate/mario_rl_tutorial.html

 

https://github.com/yfeng997/MadMario

 

本文项目地址:https://github.com/likemango/DQN-mario-xiaoyao

 

一、Basic DQN

 

DQN用一个神经网络替换Q-Learning中的最优动作价值函数Q*表格,弥补了Q-Learning只能表示有限个状态的缺陷。训练DQN网络模型常见的代码流程如下:

 

def train(cfg, env, agent):
''' 训练
    '''
print('开始训练!')
print(f'环境:{cfg.env_name}, 算法:{cfg.algo_name}, 设备:{cfg.device}')
    rewards = []  # 记录所有回合的奖励
    ma_rewards = []  # 记录所有回合的滑动平均奖励
for i_ep in range(cfg.train_eps):
        ep_reward = 0  # 记录一回合内的奖励
        state = env.reset()  # 重置环境,返回初始状态
while True:
            action = agent.choose_action(state)  # 选择动作
            next_state, reward, done, _ = env.step(action)  # 更新环境,返回transition
            agent.memory.push(state, action, reward,
                              next_state, done)  # 保存transition
            state = next_state  # 更新下一个状态
            agent.update()  # 更新智能体
            ep_reward += reward  # 累加奖励
if done:
break
        rewards.append(ep_reward)
if ma_rewards:
            ma_rewards.append(0.9 * ma_rewards[-1] + 0.1 * ep_reward)
else:
            ma_rewards.append(ep_reward)
if (i_ep + 1) % 10 == 0:
print('回合:{}/{}, 奖励:{}'.format(i_ep + 1, cfg.train_eps, ep_reward))
print('完成训练!')
    env.close()
return rewards, ma_rewards

 

其中cfg表示训练过程中的参数,env表示训练的交互环境,agent表示一个DQN的类对象。DQN类中的核心内容有:经验缓存(memory)、动作选择(choose_action)和模型参数更新(update)这三个部分
:memory用于存储训练过程中的经验五元组(state,action,reward,next_state,done);choose_action方法实现了输入状态state,输出相应的动作结果,一般采用ε-greedy方法,探索概率为ε,网络选择动作概率为1-ε,这是DQN训练中重要的超参数之一;在update方法中,采样memory中的五元组信息,使用TD(temporary difference)算法进行计算出TD target和TD Error,再通过做反向梯度计算,最后做模型参数更新(https://datawhalechina.github.io/easy-rl/#/chapter3/chapter3?id=temporal-difference)。

 

Basic DQN能够解决一些简单的离散动作问题,例如gym环境中的“CartPole”,然而对于稍微复杂的环境却难以得到好的效果。DQN方法的缺点是存在非均匀的高估问题(OverEstimate),在多轮学习更新中,会造成最优动作价值函数Q*偏离真实值,使得网络无法输出正确的结果(https://datawhalechina.github.io/easy-rl/#/chapter7/chapter7)。

 

高估发生在两个地方:

 

1.Update中计算TD target时取最大化操作。

 

2.Update中的自举(bootstraping)操作。

 

一些常见的改进办法是对Update方法以及网络模型进行优化,尽可能的减小高估问题,下面介绍一些易于实现且高效的改进方法。

 

二、Nature DQN

 

所谓自举,即利用网络模型自己去更新自己,既然自举会造成高估问题,那幺可以不用网络本身去更新自己——一个直接的想法是使用另一个新的网络去更新DQN网络。新网络的模型结构与DQN本身一样,在计算TD target时使用该网络的计算结果,因而也称该网络为目标网络(target network)。结合上面介绍的Basic DQN,NatureDQN的实现如下(policy_net为DQN网络,target_net为目标网络):

 

class DQN:
    def __init__(self, state_dim, action_dim, cfg):
        self.action_dim = action_dim  # 总的动作个数
        self.device = cfg.device  # 设备,cpu或gpu等
        self.gamma = cfg.gamma  # 奖励的折扣因子
# e-greedy策略相关参数
        self.frame_idx = 0  # 用于epsilon的衰减计数
        self.epsilon = lambda frame_idx: cfg.epsilon_end + (cfg.epsilon_start - cfg.epsilon_end) * \
            math.exp(-1. * frame_idx / cfg.epsilon_decay)
        self.batch_size = cfg.batch_size
        self.policy_net = MLP(state_dim, action_dim,hidden_dim=cfg.hidden_dim).to(self.device)
        self.target_net = MLP(state_dim, action_dim,hidden_dim=cfg.hidden_dim).to(self.device)
# 复制参数到目标网路targe_net
for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): 
            target_param.data.copy_(param.data)
        self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr) # 优化器
        self.memory = ReplayBuffer(cfg.memory_capacity) # 经验回放
    def choose_action(self, state):
''' 选择动作
        '''
        self.frame_idx += 1
if random.random() > self.epsilon(self.frame_idx):
            with torch.no_grad():
                state = torch.tensor([state], device=self.device, dtype=torch.float32)
                q_values = self.policy_net(state)
                action = q_values.max(1)[1].item() # 选择Q值最大的动作
else:
            action = random.randrange(self.action_dim)
return action
    def update(self):
if len(self.memory) < self.batch_size: # 当memory中不满足一个批量时,不更新策略
return
# 从经验回放中(replay memory)中随机采样一个批量的转移(transition)
        state_batch, action_batch, reward_batch, next_state_batch, done_batch = self.memory.sample(
            self.batch_size)
# 转为张量
        state_batch = torch.tensor(state_batch, device=self.device, dtype=torch.float)
        action_batch = torch.tensor(action_batch, device=self.device).unsqueeze(1)  
        reward_batch = torch.tensor(reward_batch, device=self.device, dtype=torch.float)  
        next_state_batch = torch.tensor(next_state_batch, device=self.device, dtype=torch.float)
        done_batch = torch.tensor(np.float32(done_batch), device=self.device)
# 计算当前状态(s,a)对应的Q(s, a)
        q_values = self.policy_net(state_batch).gather(dim=1, index=action_batch) 
# 计算下一时刻的状态(s_t,a)对应的Q值
        next_q_values = self.target_net(next_state_batch).max(1)[0].detach() 
# 计算期望的Q值,对于终止状态,此时done_batch[0]=1, 对应的expected_q_value等于reward
        expected_q_values = reward_batch + self.gamma * next_q_values * (1-done_batch)
        loss = nn.MSELoss()(q_values, expected_q_values.unsqueeze(1))  # 计算均方根损失
# 优化更新模型
        self.optimizer.zero_grad()  
        loss.backward()
for param in self.policy_net.parameters():  # clip防止梯度爆炸
            param.grad.data.clamp_(-1, 1)
        self.optimizer.step()

 

在一定更新回合后需要将DQN网络参数复制给目标网络,只需要在训练中增加如下代码:

 

        if (i_ep + 1) % cfg.target_update == 0:  # 智能体目标网络更新
            agent.target_net.load_state_dict(agent.policy_net.state_dict())

 

三、Double DQN

 

在NatureDQN中,执行网络参数更新方法update时,用target_net计算next_q_values用到了取最大值操作,其目的是获得在状态next_state时,target_net取最大值的动作a*_target,并输出该最大值Q*_max_target值,这一步同样会造成高估问题。既然如此,不采用a*_target并减小Q*_max_target值,那幺高估问题就能在一定程度得到缓解。

 

Double DQN的做法是利用policy_net在next_state时,policy_net取最大值的动作为a*_policy,然后再将该动作带入target_net中进行计算获得新的Q*_max_target^值。由于最优动作选自policy_net而不是target_net,所以容易得出target_net(next_state)[a*_target] >= target_net(next_state)[a*_policy],因此有Q*_max_target^ <=Q*_max_target
,这样一定程度减小Q估计,缓解因自举高估带来的不稳定问题。在update方法中对expected_q_values的计算做如下修改:

 

        # 计算当前状态(s,a)对应的Q(s, a)
        q_values = self.policy_net(state_batch).gather(dim=1, index=action_batch) 
# next_q_values = self.target_net(next_state_batch).max(1)[0].detach() 
# 用policy_net计算下一个状态s_t的最优动作a*
        next_action_batch = torch.argmax(self.policy_net(state_batch),axis=1).unsueeze(1)
# 用target_net计算下一时刻的状态(s_t_,a)对应的Q值
        next_q_values = self.target_net(next_state_batch).gather(dim=1,index=next_action_batch)
# 计算期望的Q值,对于终止状态,此时done_batch[0]=1, 对应的expected_q_value等于reward
        expected_q_values = reward_batch + self.gamma * next_q_values * (1-done_batch)
        loss = nn.MSELoss()(q_values, expected_q_values.unsqueeze(1))  # 计算均方根损失
# 优化更新模型
        self.optimizer.zero_grad()  
        loss.backward()
for param in self.policy_net.parameters():  # clip防止梯度爆炸
            param.grad.data.clamp_(-1, 1)
        self.optimizer.step()

 

四、Dueling DQN

 

Dueling DQN与上述两种优化方式不同,它直接修改网络模型,用一个A*网络和V*网络去表示Q*,其中A*表示为最优优势函数(optimal advantage function),V*表示最优状态价值函数(optimal state value function ),它们三者的关系为A* = Q* – V*(https://datawhalechina.github.io/easy-rl/#/chapter7/chapter7?id=dueling-dqn)。

 

Dueling DQN与原始DQN网络结构的对比如下图所示:

 

 

 

同时为了降低采用不同动作时Q*值的方差,实际中常用Q* = V* + A* – mean(A*)来进一步优化网络,加速收敛。在代码角度上,常见的 Dueling网络模型实现如下:

 

class DuelingNet(nn.Module):
    def __init__(self, state_dim, action_dim,hidden_size=128):
        super(DuelingNet, self).__init__()
# 隐藏层
        self.hidden = nn.Sequential(
            nn.Linear(state_dim, hidden_size),
            nn.ReLU()
        )
# 优势函数
        self.advantage = nn.Sequential(
            nn.Linear(hidden_size, hidden_size),
            nn.ReLU(),
            nn.Linear(hidden_size, action_dim)
        )
# 价值函数
        self.value = nn.Sequential(
            nn.Linear(hidden_size, hidden_size),
            nn.ReLU(),
            nn.Linear(hidden_size, 1)
        )
    def forward(self, x):
        x = self.hidden(x)
        advantage = self.advantage(x)
        value     = self.value(x)
# Q* = A* + V* - mean(A*) 
return value + advantage  - advantage.mean()

 

五、官方代码及模型分析

 

本文在DQN训练超级马里奥的项目中,参考了pytorch官方的强化学习教程,该教程代码耦合度低,逻辑结构清晰,非常值得初学者学习。核心代码及其功能如下图所示:

 

 

 

超级马里奥的训练环境来自

 

gym_super_mario_bros(https://github.com/flexpad/gym-super-mario-bros),代理(agent)与环境(env)交互返回的是游戏当前的RGB图像,因而在开始训练之前需要对图像做一系列的预处理操作,该教程的这部分工作做的十分完善,非常值得学习和借鉴。在完成预处理数据后,我们就集中精力在DQN的算法实现上。官方代码的具体分析可以在这篇文章中找到:https://zhuanlan.zhihu.com/p/402519441?utm_source=wechat_session&utm_medium=social&utm_oi=951210242982260736.

 

笔者应用该代码在实际训练中还发现一些问题:

 

 

首先是直接训练该模型对硬件设备要求高,很可能会出现显存不足的问题(报错:”CUDA out of memory”);

 

其次是训练结果模型效果不佳,根据官方提供的已训练完成的模型去测试(官方给出训练时间为GPU约20小时,CPU约80小时,但未说明具体设备),发现通关率仍然较低(笔者测试每回合累积奖励大约在1300~2000之间,小概率能够通关;笔者对模型修改后训练测试结果是稳定通关且每回合累积奖励3032);

 

最后是探索率设置不够合理,DQN模型训练完成后,在实际使用时应该将探索率ε设置为0,然而原作者依然给出了0.1的探索率,将该探索率设置为0后会出现每次agent都在同一地方失败(例如“卡墙角”)等现象,推测原作者之所以这样做,目的是防止agent总是在同样决策下走向相同的失败结局而有意增加了随机性,这有悖于DQN的算法原理。DQN算法的决策过程决定了它是一种确定性的策略,也就是说,对给定的输入状态,每次的输出结果都是相同的
,如果在训练完成后,实际测试时还需要增加探索率去避免“卡墙角”或者“碰壁”等情况,那只能说明模型没有训练好,有待于对模型做进一步改进,最终训练好的结果一定是agent每次都会以相同的策略通关而不存在随机性;如果想得到每回合游戏有不一样的通关方式,那幺就需要考虑采用其他算法,例如策略学习算法,每一次的动作做概率抽样。

 

 

六、模型改进

 

针对上述问题,笔者对官方模型做出如下修改:

 

 

修改经验缓存memory的大小。原则上来说,经验缓存越大,那幺能够存储更加久远的对局信息,是有助于模型学习与改进的,然而受限于硬件显存空间的问题,可以考虑降低经验缓存的大小;而且基于直觉判断,超级马里奥第一关的环境也并没有太过复杂,因而适当降低缓存大小,在较为低配的硬件设备上依然可以得到不错的训练效果。(笔者机器配置为i7-9750H和GTX1660Ti,显存6G,笔者在本机和Colab上均做过尝试,将memory从100000调整为18000可以完成训练。如果不更改配置至少需要20G显存,读者可更具机器硬件情况进行调整)。

 

模型改进。将官方给出D2QN(Nature DQN + Double DQN)改为D3QN(Nature DQN + Double DQN + Dueling DQN).DQN算法本身不可避免的存在高估等问题,使用这些DQN变体能够大幅提高DQN算法的准确性和稳定性(https://zhuanlan.zhihu.com/p/98784255?utm_source=wechat_session&utm_medium=social&utm_oi=951210242982260736)。在官方代码基础上,使用Dueling network对原文件中”neural.py”的网络模型进行修改。

 

调整超参数。将探索率ε的最小值设置为0,设置更大的BatchSize并减小的学习率,DQN调参可以参考(https://zhuanlan.zhihu.com/p/345353294)

 

 

七、训练结果

 

笔者使用笔记本训练,总时间为24+13+10=47小时,根据不同的硬件环境,训练时间可能会有较大变化。0~24小时、24~37小时、37~47小时三个阶段每百回合平均奖励的变化如图所示:

 

 

训练第一阶段的每百回合平均奖励

 

训练第二阶段的每百回合平均奖励

 

训练的第三阶段的每百回合平均奖励

从图中可以看出,在局部区域奖励波动较大,一般属于正常情况,总体上看,平均奖励是随着训练的进行而上升的,说明模型的表现已经越来越好。在训练之余,还可以通过replay.py对已经训练出来的模型进行测试,以验证模型学习的进步(最后一个阶段的奖励虽然在升高,但是还没有达到测试时的3032,原因是此时依然有较低的概率在做随机探索。同时,强化学习的模型并不是训练的越久越好,选择训练阶段中奖励更高的模型往往会是一种更优的选择)。测试模型结果:

 

 

 

八、总结

 

DQN算法作为强化学习的入门算法之一,将强化学习的核心理论(马尔科夫决策过程、贝尔曼方程等)清晰的融入到算法的实现中,基于DQN算法中的问题,又催生出各式各样DQN算法变体,大幅提高了算法的有效性。在解决离散动作空间的问题上,D3QN(Dueling DDQN)通常都具有不错的表现。大家可以结合实际游戏环境或者参考项目源代码,训练出属于你自己的超级马里奥!

 

Be First to Comment

发表评论

您的电子邮箱地址不会被公开。