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

项目描述:

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

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

  • 小车可执行的动作包括:向上走 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()  

作者:杨飞

来源:宜信技术学院 (http://college.creditease.cn/)

### 回答1: Q-learning算法是一种基于强化学习的路径规划方法,它可以在机器人的环境中根据奖励来确定下一步的动作,进而最终到达目标位置。在MATLAB中,我们可以使用Q-learning算法实现机器人的路径规划。 首先,我们需要建立机器人的环境模型,包括机器人的起始位置和目标位置、障碍物的位置等信息。然后定义状态空间和动作空间,状态空间是机器人当前所在的位置,动作空间是机器人可以采取的移动方式。同时,需要设定奖励函数,即对机器人采取不同的动作在不同的状态下所获得的奖励。 接着,我们可以使用Q-learning算法,这个算法主要是根据机器人当前的状态和奖励来更新Q值,从而得到最优的路径规划结果。在MATLAB中,我们可以使用相关的函数和工具箱来实现Q-learning算法,如qlearn函数和repmat函数等。 最后,我们可以通过可视化工具来展示机器人的路径规划结果,例如绘制机器人在环境中的运动轨迹。这样,我们就可以通过MATLAB实现Q-learning算法在环境中移动机器人的路径规划。 ### 回答2: 机器学习中的Q-Learning算法是一种基于试错方法的无模型学习算法,能够让机器在与外界交互的过程中逐步学习到最优策略。在路径规划问题中,Q-Learning算法可以帮助机器人通过与环境的交互,找到最优的路径规划策略。 实现Q-learning算法在Matlab中移动机器人的路径规划,需要分为以下几个步骤: 1. 确定机器人的状态空间、动作空间和奖励函数: 机器人的状态空间可以通过环境中的传感器获取,可以是机器人所在的位置、姿态等;动作空间指的是机器人可以采取的行动,如向前、向后等;奖励函数用于评估机器人当前状态所采取的行动的优劣,可以是到达目标点的奖励或者碰到障碍物的惩罚。 2. 初始化Q-table: Q-table是Q-Learning算法中保存每个状态下采取不同动作的价值的表格,需要先进行初始化。可以将Q-table的初始值设置为0,也可以随机生成一个初值。 3. 选择动作: 机器人在每个状态下选择采取的动作时,需要考虑到当前状态下每个动作的价值,根据贪心算法选择价值最大的动作或者随机选择一个动作。 4. 更新Q-table: 机器人采取一次动作后,需要更新Q-table中当前状态下采取该动作的价值。这里采用Q-Learning算法的公式:Q(state, action) = Q(state, action) + learning_rate * (reward + gamma * max(Q(next_state, all_actions)) - Q(state, action)),其中learning_rate是学习率,gamma是折扣因子,reward是奖励函数的值。 5. 重复步骤3和4: 机器人不断选择动作和更新Q-table,直到达到目标点或者碰到障碍物。 通过以上步骤,机器人可以逐渐通过与环境的交互,找到最优的路径规划策略。在实现过程中,需要注意学习率和折扣因子的选择,以及如何设计合适的奖励函数,从而达到更好的路径规划效果。 ### 回答3: Q-learning算法是一种基于强化学习的决策方法,可以用来解决机器人路径规划问题。而在matlab中实现Q-learning算法的过程,主要分为三个步骤:建模、训练和使用。 首先,我们需要建立一个机器人和环境的模型。在该模型中,机器人可以感知到环境中的状态,并且可以采取某些行动来改变其所处的状态。同时,我们需要定义一个奖励函数,来指导机器人在不同状态下选择行动的好坏。这个奖励函数可以根据具体的应用需求来设计。 在有了模型之后,我们就可以开始使用Q-learning算法进行训练了。训练的过程主要是机器人在不断地与环境进行交互,并利用之前学习到的经验来更新其策略。具体来说,我们需要在每个状态下记录该状态的Q值,并在机器人选择行动后,计算出新的Q值并进行更新。Q值的更新可以采用如下公式: Q(S,A) = Q(S,A) + α[R + γmaxQ(S',a) - Q(S,A)] 其中,Q(S,A)是状态S下采取行动A的当前估计值,α是学习率,R是在状态S下采取行动A所获得的即时奖励,γ是折扣因子,表示在未来时间步的奖励的重要程度,maxQ(S',a)是在状态S'下采取所有可能的行动a所获得的最大Q值。通过不断地迭代更新Q值,机器人就可以逐渐学习到最优的策略。 最后,要使用机器人完成路径规划任务,我们只需要根据训练得到的Q值表,选择在当前状态下可以带来最大Q值的行动,即可完成机器人的路径规划。 综上所述,matlab实现Q-learning算法在环境中移动机器人的路径规划,需要先建立机器人和环境的模型,然后利用Q-learning算法进行训练,最后根据训练得到的Q值表来指导机器人完成路径规划任务。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值