当前位置: 移动技术网 > IT编程>脚本编程>Python > 用Q-learning算法实现自动走迷宫机器人的方法示例

用Q-learning算法实现自动走迷宫机器人的方法示例

2019年07月21日  | 移动技术网IT编程  | 我要评论

99bu,诗词作品归于哪一类,彭州px

项目描述:

在该项目中,你将使用强化学习算法,实现一个自动走迷宫机器人。

如上图所示,智能机器人显示在右上角。在我们的迷宫中,有陷阱(红色×××)及终点(蓝色的目标点)两种情景。机器人要尽量避开陷阱、尽快到达目的地。

小车可执行的动作包括:向上走 u、向右走 r、向下走 d、向左走l

执行不同的动作后,根据不同的情况会获得不同的奖励,具体而言,有以下几种情况。

  • 撞到墙壁:-10
  • 走到终点:50
  • 走到陷阱:-30
  • 其余情况:-0.1

我们需要通过修改 robot.py 中的代码,来实现一个 q learning 机器人,实现上述的目标。

section 1 算法理解

1.1 强化学习总览

强化学习作为机器学习算法的一种,其模式也是让智能体在“训练”中学到“经验”,以实现给定的任务。但不同于监督学习与非监督学习,在强化学习的框架中,我们更侧重通过智能体与环境的交互来学习。通常在监督学习和非监督学习任务中,智能体往往需要通过给定的训练集,辅之以既定的训练目标(如最小化损失函数),通过给定的学习算法来实现这一目标。然而在强化学习中,智能体则是通过其与环境交互得到的奖励进行学习。这个环境可以是虚拟的(如虚拟的迷宫),也可以是真实的(自动驾驶汽车在真实道路上收集数据)。

在强化学习中有五个核心组成部分,它们分别是:环境(environment)、智能体(agent)、状态(state)、动作(action)和奖励(reward)。在某一时间节点t:

智能体在从环境中感知其所处的状态

智能体根据某些准则选择动作

环境根据智能体选择的动作,向智能体反馈奖励

通过合理的学习算法,智能体将在这样的问题设置下,成功学到一个在状态 选择动作 的策略

1.2 计算q值

在我们的项目中,我们要实现基于 q-learning 的强化学习算法。q-learning 是一个值迭代(value iteration)算法。与策略迭代(policy iteration)算法不同,值迭代算法会计算每个”状态“或是”状态-动作“的值(value)或是效用(utility),然后在执行动作的时候,会设法最大化这个值。因此,对每个状态值的准确估计,是我们值迭代算法的核心。通常我们会考虑最大化动作的长期奖励,即不仅考虑当前动作带来的奖励,还会考虑动作长远的奖励。

在 q-learning 算法中,我们把这个长期奖励记为 q 值,我们会考虑每个 ”状态-动作“ 的 q 值,具体而言,它的计算公式为:

也就是对于当前的“状态-动作” ,我们考虑执行动作 后环境给我们的奖励,以及执行动作 到达 后,执行任意动作能够获得的最大的q值为折扣因子。

不过一般地,我们使用更为保守地更新 q 表的方法,即引入松弛变量 alpha,按如下的公式进行更新,使得 q 表的迭代变化更为平缓。

根据已知条件求

已知:如上图,机器人位于 s1,行动为 u,行动获得的奖励与题目的默认设置相同。在 s2 中执行各动作的 q 值为:u: -24,r: -13,d: -0.29、l: +40,γ取0.9。

1.3 如何选择动作

在强化学习中,「探索-利用」问题是非常重要的问题。具体来说,根据上面的定义,我们会尽可能地让机器人在每次选择最优的决策,来最大化长期奖励。但是这样做有如下的弊端:

  • 在初步的学习中,我们的 q 值会不准确,如果在这个时候都按照 q 值来选择,那么会造成错误。
  • 学习一段时间后,机器人的路线会相对固定,则机器人无法对环境进行有效的探索。

因此我们需要一种办法,来解决如上的问题,增加机器人的探索。由此我们考虑使用 epsilon-greedy 算法,即在小车选择动作的时候,以一部分的概率随机选择动作,以一部分的概率按照最优的 q 值选择动作。同时,这个选择随机动作的概率应当随着训练的过程逐步减小。

在如下的代码块中,实现 epsilon-greedy 算法的逻辑,并运行测试代码。

import random 
import operator 

actions = ['u','r','d','l'] 
qline = {'u':1.2, 'r':-2.1, 'd':-24.5, 'l':27} 
epsilon = 0.3 # 以0.3的概率进行随机选择 

def choose_action(epsilon):     
  action = none 
   if random.uniform(0,1.0) <= epsilon: # 以某一概率 
    action = random.choice(actions)# 实现对动作的随机选择 
   else:  
     action = max(qline.items(), key=operator.itemgetter(1))[0] # 否则选择具有最大 q 值的动作 
   return action 
range(100): 

  res += choose_action(epsilon) 

print(res) 

res = '' 

for i in range(100): 

   res += choose_action(epsilon) 

print(res) 
 ldllrrllllrlldlldllllllllllddulldlllllldllllludlldllllluudllllllulllllllllllullullllllllldlulllllrlr

section 2 代码实现

2.1 maze 类理解

我们首先引入了迷宫类 maze,这是一个非常强大的函数,它能够根据你的要求随机创建一个迷宫,或者根据指定的文件,读入一个迷宫地图信息。

  • 使用 maze("file_name") 根据指定文件创建迷宫,或者使用 maze(maze_size=(height, width))来随机生成一个迷宫。
  • 使用 trap number 参数,在创建迷宫的时候,设定迷宫中陷阱的数量。
  • 直接键入迷宫变量的名字按回车,展示迷宫图像(如 g=maze("xx.txt"),那么直接输入 g 即可。
  • 建议生成的迷宫尺寸,长在 6~12 之间,宽在 10~12 之间。

在如下的代码块中,创建你的迷宫并展示。

from maze import maze 
%matplotlib inline 
%confer inlinebackend.figure_format = 'retina' 
  ## to-do: 创建迷宫并展示 
g=maze(maze_size=(6,8), trap_number=1) 
g 
maze of size (12, 12
)

你可能已经注意到,在迷宫中我们已经默认放置了一个机器人。实际上,我们为迷宫配置了相应的 api,来帮助机器人的移动与感知。其中你随后会使用的两个 api 为 maze.sense_robot()maze.move_robot()

  • maze.sense_robot() 为一个无参数的函数,输出机器人在迷宫中目前的位置。
  • maze.move_robot(direction) 对输入的移动方向,移动机器人,并返回对应动作的奖励值。

随机移动机器人,并记录下获得的奖励,展示出机器人最后的位置。

rewards = []   
 ## 循环、随机移动机器人10次,记录下奖励 
for i in range(10): 
  res = g.move_robot(random. choice(actions)) 
   rewards.append(res)   
 ## 输出机器人最后的位置 
print(g.sense_robot())   
## 打印迷宫,观察机器人位置 
g 

(0,9)

2.2 robot 类实现

robot 类是我们需要重点实现的部分。在这个类中,我们需要实现诸多功能,以使得我们成功实现一个强化学习智能体。总体来说,之前我们是人为地在环境中移动了机器人,但是现在通过实现 robot 这个类,机器人将会自己移动。通过实现学习函数,robot 类将会学习到如何选择最优的动作,并且更新强化学习中对应的参数。

首先 robot 有多个输入,其中 alpha=0.5, gamma=0.9, epsilon0=0.5 表征强化学习相关的各个参数的默认值,这些在之前你已经了解到,maze 应为机器人所在迷宫对象。

随后观察 robot.update 函数,它指明了在每次执行动作时,robot 需要执行的程序。按照这些程序,各个函数的功能也就明了了。

运行如下代码检查效果(记得将 maze 变量修改为你创建迷宫的变量名)。

import random 
import operator    

 class robot(object):  

  def __init__(self, maze, alpha=0.5, gamma=0.9, epsilon0=0.5):  

     self. maze = maze 
     self.valid_actions = self.maze.valid_actions 

     self.state = none 
     self.action = none   

     # set parameters of the learning robot 
     self.alpha = alpha 
     self.gamma = gamma  

     self.epsilon0 = epsilon0 
     self. epsilon = epsilon0 
     self.t = 0  

     self.qtable = {} 
     self. reset()  

  def. reset(self): 
     """ 
         reset the robot 
     """ 
     self.state = self.sense_state() 
     self.create_qtable_line(self.state)  

  def. set status(self, learning=false, testing=false): 
     """ 
     determine whether the robot is learning its q table, or 
     executing the testing procedure. 
     """ 
     self. learning = learning 
     self.testing = testing   

   def. update_parameter(self): 
     """ 
     some of the paramters of the q learning robot can be altered, 
     update these parameters when necessary. 
     """ 
     if self.testing: 
       # todo 1. no random choice when testing 
      self. epsilon = 0 
     else: 
       # todo 2. update parameters when learning 
       self. epsilon *= 0.95   

    return self. epsilon   

   def. sense_state(self): 
     """ 
     get the current state of the robot. in this 
     """ 

      # todo 3. return robot's current state 
          return self.maze.sense_robot()  

   def. create_qtable_line(self, state): 
    """ 
     create the qtable with the current state 
    """ 
     # todo 4. create qtable with current state 
     # our qtable should be a two level dict, 
     # qtable[state] ={'u':xx, 'd':xx, ...} 
     # if qtable[state] already exits, then do 
     # not change it. 
     self.qtable.setdefault(state, {a: 0.0 for a in self.valid_actions})       
   def. choose_action(self): 
     """ 
    return an action according to given rules 
     """   
     def. is_random_exploration():  

       # todo 5. return whether do random choice 
       # hint: generate a random number, and compare 
       # it with epsilon 
      return random.uniform(0, 1.0) <= self. epsilon 

     if self. learning: 
       if is_random_exploration(): 
        # todo 6. return random choose aciton 
         return random. choice(self.valid_actions) 
       else: 
         # todo 7. return action with highest q value 
         return max(self.qtable[self.state].items(), key=operator.itemgetter(1))[0] 
     elif self.testing: 
       # todo 7. choose action with highest q value 
       return max(self.qtable[self.state].items(), key=operator.itemgetter(1))[0] 
     else: 
       # todo 6. return random choose aciton 
      return random. choice(self.valid_actions)   

  def. update_qtable(self, r, action, next_state): 
     """ 
     update the qtable according to the given rule. 
     """ 
     if self. learning: 
       # todo 8. when learning, update the q table according 
       # to the given rules 
      self.qtable[self.state][action] = (1 - self.alpha) * self.qtable[self.state][action] + self.alpha * ( 
             r + self.gamma * max(self.qtable[next_state].values())) 

  def. update(self): 
       """ 
     describle the procedure what to do when update the robot. 
    called every time in every epoch in training or testing. 
     return current action and reward. 
     """ 
     self.state = self.sense_state() # get the current state 
     self.create_qtable_line(self.state) # for the state, create q table line 

    action = self.choose_action() # choose action for this state 
     reward = self.maze.move_robot(action) # move robot for given action 

    next_state = self.sense_state() # get next state 
     self.create_qtable_line(next_state) # create q table line for next state 

     if self. learning and not self.testing: 
       self.update_qtable(reward, action, next_state) # update q table 
      self.update_parameter() # update parameters   

    return action, reward 
 # from robot import robot 
 # g=maze(maze_size=(6,12), trap_number=2) 
 g=maze("test_world\maze_01.txt") 
 robot = robot(g) # 记得将 maze 变量修改为你创建迷宫的变量名 
 robot.set_status(learning=true,testing=false) 
 print(robot.update())  

 g 
('d', -0.1)
maze of size (12, 12)

2.3 用 runner 类训练 robot

在完成了上述内容之后,我们就可以开始对我们 robot 进行训练并调参了。我们准备了又一个非常棒的类 runner ,来实现整个训练过程及可视化。使用如下的代码,你可以成功对机器人进行训练。并且你会在当前文件夹中生成一个名为 filename 的视频,记录了整个训练的过程。通过观察该视频,你能够发现训练过程中的问题,并且优化你的代码及参数。

尝试利用下列代码训练机器人,并进行调参。可选的参数包括:

  • 训练参数
    • 训练次数 epoch
  • 机器人参数:
    • epsilon0 (epsilon 初值)
    • epsilon 衰减(可以是线性、指数衰减,可以调整衰减的速度),你需要在 robot.py 中调整
    • alpha
    • gamma
  • 迷宫参数:
    • 迷宫大小
    • 迷宫中陷阱的数量
  • 可选的参数:
  • epoch = 20
  • epsilon0 = 0.5
  • alpha = 0.5
  • gamma = 0.9
  • maze_size = (6,8)
  • trap_number = 2
from runner import runner 

g = maze(maze_size=maze_size,trap_number=trap_number) 
r = robot(g,alpha=alpha, epsilon0=epsilon0, gamma=gamma) 
r.set_status(learning=true) 

 runner = runner(r, g) 
runner.run_training(epoch, display_direction=true) 
 #runner.generate_movie(filename = "final1.mp4") # 你可以注释该行代码,加快运行速度,不过你就无法观察到视频了。 
 g

使用 runner.plot_results() 函数,能够打印机器人在训练过程中的一些参数信息。

  • success times 代表机器人在训练过程中成功的累计次数,这应当是一个累积递增的图像。
  • accumulated rewards 代表机器人在每次训练 epoch 中,获得的累积奖励的值,这应当是一个逐步递增的图像。
  • running times per epoch 代表在每次训练 epoch 中,小车训练的次数(到达终点就会停止该 epoch 转入下次训练),这应当是一个逐步递减的图像。

使用 runner.plot_results() 输出训练结果

 runner.plot_results() 

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持移动技术网。

如对本文有疑问,请在下面进行留言讨论,广大热心网友会与你互动!! 点击进行留言回复

相关文章:

验证码:
移动技术网