用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() 輸出訓練結果。