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

时间  2019-12-04
标签 learning 算法 实现 自动 迷宫 机器人 繁體版
原文   原文链接

【技术沙龙002期】数据中台：宜信敏捷数据中台建设实践|宜信技术沙龙 将于5月23日晚8点线上直播，点击报名算法

项目描述：

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

  • 如上图所示，智能机器人显示在右上角。在咱们的迷宫中，有陷阱（红色炸弹）及终点（蓝色的目标点）两种情景。机器人要尽可能避开陷阱、尽快到达目的地。
  • 小车可执行的动做包括：向上走 u、向右走 r、向下走 d、向左走l。

  • 执行不一样的动做后，根据不一样的状况会得到不一样的奖励，具体而言，有如下几种状况。框架

    • 撞到墙壁：-10
    • 走到终点：50
    • 走到陷阱：-30
    • 其他状况：-0.1
  • 咱们须要经过修改 robot.py 中的代码，来实现一个 Q Learning 机器人，实现上述的目标。

Section 1 算法理解

1.1 强化学习总览

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

在强化学习中有五个核心组成部分，它们分别是：环境（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 表的迭代变化更为平缓。this

根据已知条件求。

已知：如上图，机器人位于 s1，行动为 u，行动得到的奖励与题目的默认设置相同。在 s2 中执行各动做的 Q 值为：u: -24，r: -13，d: -0.2九、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()

做者：杨飞

来源：宜信技术学院 （http://college.creditease.cn/）

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程