我們將會應用 Q-learning 演算法完成一個經典的 Markov 決策問題 -- 走迷宮！

專案描述：

在該專案中，你將使用強化學習演算法，實現一個自動走迷宮機器人。

1. 如上圖所示，智慧機器人顯示在右上角。在我們的迷宮中，有陷阱（紅色炸彈）及終點（藍色的目標點）兩種情景。機器人要儘量避開陷阱、儘快到達目的地。

2. 小車可執行的動作包括：向上走 u、向右走 r、向下走 d、向左走 l。

3. 執行不同的動作後，根據不同的情況會獲得不同的獎勵，具體而言，有以下幾種情況。

   • 撞到牆壁：-10

   • 走到終點：50

   • 走到陷阱：-30

   • 其餘情況：-0.1

4. 我們需要通過修改 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如何選擇動作

在強化學習中，「探索-利用」問題是非常重要的問題。具體來說，根據上面的定義，我們會盡可能地讓機器人在每次選擇最優的決策，來最大化長期獎勵。但是這樣做有如下的弊端：

1. 在初步的學習中，我們的 Q 值會不準確，如果在這個時候都按照 Q 值來選擇，那麼會造成錯誤。

2. 學習一段時間後，機器人的路線會相對固定，則機器人無法對環境進行有效的探索。

因此我們需要一種辦法，來解決如上的問題，增加機器人的探索。由此我們考慮使用 epsilon-greedy 演算法，即在小車選擇動作的時候，以一部分的概率隨機選擇動作，以一部分的概率按照最優的 Q 值選擇動作。同時，這個選擇隨機動作的概率應當隨著訓練的過程逐步減小。

在如下的程式碼塊中，實現 epsilon-greedy 演算法的邏輯，並執行測試程式碼。

1.  import random  

2.  import operator  

3.    

4.  actions = ['u','r','d','l']  

5.  qline = {'u':1.2, 'r':-2.1, 'd':-24.5, 'l':27}  

6.  epsilon = 0.3 # 以0.3的概率進行隨機選擇  

7.    

8.  def choose_action(epsilon):  

9.        

10.     action = None  

11.     if random.uniform(0,1.0) <=  epsilon: # 以某一概率  

12.         action = random.choice(actions)# 實現對動作的隨機選擇  

13.     else:   

14.         action = max(qline.items(), key=operator.itemgetter(1))[0] # 否則選擇具有最大 Q 值的動作  

15.     return action  





1.  range(100):  

2.      res += choose_action(epsilon)  

3.  print(res)  

4.  res = ''  

5.  for i in range(100):  

6.      res += choose_action(epsilon)  

7.  print(res)  

8.  ldllrrllllrlldlldllllllllllddulldlllllldllllludlldllllluudllllllulllllllllllullullllllllldlulllllrlr

Section 2 程式碼實現

2.1. Maze 類理解

我們首先引入了迷宮類 Maze，這是一個非常強大的函式，它能夠根據你的要求隨機建立一個迷宮，或者根據指定的檔案，讀入一個迷宮地圖資訊。

1. 使用 Maze("file_name") 根據指定檔案建立迷宮，或者使用 Maze(maze_size=(height,      width)) 來隨機生成一個迷宮。

2. 使用 trap number 引數，在建立迷宮的時候，設定迷宮中陷阱的數量。

3. 直接鍵入迷宮變數的名字按回車，展示迷宮影象（如 g=Maze("xx.txt")，那麼直接輸入 g 即可。

4. 建議生成的迷宮尺寸，長在 6~12 之間，寬在 10～12 之間。

在如下的程式碼塊中，建立你的迷宮並展示。

1.  from Maze import Maze  

2.  %matplotlib inline  

3.  %confer InlineBackend.figure_format = 'retina'  

4.    

5.  ## to-do: 建立迷宮並展示  

6.  g=Maze(maze_size=(6,8), trap_number=1)  

7.  g  

Maze of size (12, 12

)

 你可能已經注意到，在迷宮中我們已經預設放置了一個機器人。實際上，我們為迷宮配置了相應的 API，來幫助機器人的移動與感知。其中你隨後會使用的兩個 API 為 maze.sense_robot() 及 maze.move_robot()。

1. maze.sense_robot() 為一個無引數的函式，輸出機器人在迷宮中目前的位置。

2. maze.move_robot(direction) 對輸入的移動方向，移動機器人，並返回對應動作的獎勵值。

隨機移動機器人，並記錄下獲得的獎勵，展示出機器人最後的位置。

1.  rewards = []  

2.    

3.  ## 迴圈、隨機移動機器人10次，記錄下獎勵  

4.  for i in range(10):  

5.      res = g.move_robot(random. Choice(actions))  

6.      rewards.append(res)  

7.    

8.  ## 輸出機器人最後的位置  

9.  print(g.sense_robot())  

10.   

11. ## 列印迷宮，觀察機器人位置  

12. g  

(0,9)

2.2. Robot 類實現

Robot 類是我們需要重點實現的部分。在這個類中，我們需要實現諸多功能，以使得我們成功實現一個強化學習智慧體。總體來說，之前我們是人為地在環境中移動了機器人，但是現在通過實現 Robot 這個類，機器人將會自己移動。通過實現學習函式，Robot 類將會學習到如何選擇最優的動作，並且更新強化學習中對應的引數。

首先 Robot 有多個輸入，其中 alpha=0.5, gamma=0.9, epsilon0=0.5 表徵強化學習相關的各個引數的預設值，這些在之前你已經瞭解到，Maze 應為機器人所在迷宮物件。

隨後觀察 Robot.update 函式，它指明瞭在每次執行動作時，Robot 需要執行的程式。按照這些程式，各個函式的功能也就明瞭了。

執行如下程式碼檢查效果（記得將 maze 變數修改為你建立迷宮的變數名）。

1.  import random  

2.  import operator  

3.    

4.    

5.  class Robot(object):  

6.    

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

8.    

9.          self. Maze = maze  

10.         self.valid_actions = self.maze.valid_actions  

11.         self.state = None  

12.         self.action = None  

13.   

14.         # Set Parameters of the Learning Robot  

15.         self.alpha = alpha  

16.         self.gamma = gamma  

17.   

18.         self.epsilon0 = epsilon0  

19.         self. Epsilon = epsilon0  

20.         self.t = 0  

21.   

22.         self.Qtable = {}  

23.         self. Reset()  

24.   

25.     def. reset(self):  

26.         """ 

27.         Reset the robot 

28.         """  

29.         self.state = self.sense_state()  

30.         self.create_Qtable_line(self.state)  

31.   

32.     def. set status(self, learning=False, testing=False):  

33.         """ 

34.         Determine whether the robot is learning its q table, or 

35.         executing the testing procedure. 

36.         """  

37.         self. Learning = learning  

38.         self.testing = testing  

39.   

40.     def. update_parameter(self):  

41.         """ 

42.         Some of the paramters of the q learning robot can be altered, 

43.         update these parameters when necessary. 

44.         """  

45.         if self.testing:  

46.             # TODO 1. No random choice when testing  

47.             self. Epsilon = 0  

48.         else:  

49.             # TODO 2. Update parameters when learning  

50.             self. Epsilon *= 0.95  

51.   

52.         return self. Epsilon  

53.   

54.     def. sense_state(self):  

55.         """ 

56.         Get the current state of the robot. In this 

57.         """  

58.   

59.         # TODO 3. Return robot's current state  

60.         return self.maze.sense_robot()  

61.   

62.     def. create_Qtable_line(self, state):  

63.         """ 

64.         Create the qtable with the current state 

65.         """  

66.         # TODO 4. Create qtable with current state  

67.         # Our qtable should be a two level dict,  

68.         # Qtable[state] ={'u':xx, 'd':xx, ...}  

69.         # If Qtable[state] already exits, then do  

70.         # not change it.  

71.         self.Qtable.setdefault(state, {a: 0.0 for a in self.valid_actions})  

72.           

73.     def. choose_action(self):  

74.         """ 

75.         Return an action according to given rules 

76.         """  

77.   

78.         def. is_random_exploration():  

79.   

80.             # TODO 5. Return whether do random choice  

81.             # hint: generate a random number, and compare  

82.             # it with epsilon  

83.             return random.uniform(0, 1.0) <= self. Epsilon  

84.   

85.         if self. Learning:  

86.             if is_random_exploration():  

87.                 # TODO 6. Return random choose aciton  

88.                 return random. Choice(self.valid_actions)  

89.             else:  

90.                 # TODO 7. Return action with highest q value  

91.                 return max(self.Qtable[self.state].items(), key=operator.itemgetter(1))[0]  

92.         elif self.testing:  

93.             # TODO 7. choose action with highest q value  

94.             return max(self.Qtable[self.state].items(), key=operator.itemgetter(1))[0]  

95.         else:  

96.             # TODO 6. Return random choose aciton  

97.             return random. Choice(self.valid_actions)  

98.   

99.     def. update_Qtable(self, r, action, next_state):  

100.         """ 

101.         Update the qtable according to the given rule. 

102.         """  

103.         if self. Learning:  

104.             # TODO 8. When learning, update the q table according  

105.             # to the given rules  

106.             self.Qtable[self.state][action] = (1 - self.alpha) * self.Qtable[self.state][action] + self.alpha * (  

107.                         r + self.gamma * max(self.Qtable[next_state].values()))  

108.                           

109.   

110.   

111.     def. update(self):  

112.         """ 

113.         Describle the procedure what to do when update the robot. 

114.         Called every time in every epoch in training or testing. 

115.         Return current action and reward. 

116.         """  

117.         self.state = self.sense_state()  # Get the current state  

118.         self.create_Qtable_line(self.state)  # For the state, create q table line  

119.   

120.         action = self.choose_action()  # choose action for this state  

121.         reward = self.maze.move_robot(action)  # move robot for given action  

122.   

123.         next_state = self.sense_state()  # get next state  

124.         self.create_Qtable_line(next_state)  # create q table line for next state  

125.   

126.         if self. Learning and not self.testing:  

127.             self.update_Qtable(reward, action, next_state)  # update q table  

128.             self.update_parameter()  # update parameters  

129.   

130.         return action, reward  

131.   

132. # from Robot import Robot  

133. # g=Maze(maze_size=(6,12), trap_number=2)  

134. g=Maze("test_world\maze_01.txt")  

135. robot = Robot(g) # 記得將 maze 變數修改為你建立迷宮的變數名  

136. robot.set_status(learning=True,testing=False)  

137. print(robot.update())  

138.   

139. 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  

1.  from Runner import Runner  

2.    

3.  g = Maze(maze_size=maze_size,trap_number=trap_number)  

4.  r = Robot(g,alpha=alpha, epsilon0=epsilon0, gamma=gamma)  

5.  r.set_status(learning=True)  

6.    

7.  runner = Runner(r, g)  

8.  runner.run_training(epoch, display_direction=True)  

9.  #runner.generate_movie(filename = "final1.mp4") # 你可以註釋該行程式碼，加快執行速度，不過你就無法觀察到視訊了。  

10. g  

使用 runner.plot_results() 函式，能夠印表機器人在訓練過程中的一些引數資訊。

• Success Times 代表機器人在訓練過程中成功的累計次數，這應當是一個累積遞增的影象。

• Accumulated Rewards 代表機器人在每次訓練 epoch 中，獲得的累積獎勵的值，這應當是一個逐步遞增的影象。

• Running Times per Epoch 代表在每次訓練 epoch 中，小車訓練的次數（到達終點就會停止該 epoch 轉入下次訓練），這應當是一個逐步遞減的影象。

       使用 runner.plot_results() 輸出訓練結果。

1.  runner.plot_results()