機器學習工程師 - Udacity 強化學習 Part Six

本文轉載自查看原文 2019-02-27 19:36 994 機器學習工程師 - Udacity

項目：強化學習走迷宮

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

請查看項目詳情 https://github.com/udacity/MLND_CN_P5_Reinforcement_Learning

Section 0 問題描述與完成項目流程

1. 問題描述

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

如上圖所示，智能機器人顯示在右上角。在我們的迷宮中，有陷阱（紅色炸彈）及終點（藍色的目標點）兩種情景。機器人要盡量避開陷阱、盡快到達目的地。
小車可執行的動作包括：向上走 u、向右走 r、向下走 d、向左走 l。
執行不同的動作后，根據不同的情況會獲得不同的獎勵，具體而言，有以下幾種情況。我們需要通過修改 robot.py 中的代碼，來實現一個 Q Learning 機器人，實現上述的目標。
- 撞到牆壁：-10
- 走到終點：50
- 走到陷阱：-30
- 其余情況：-0.1
我們需要通過修改 robot.py 中的代碼，來實現一個 Q Learning 機器人，實現上述的目標。

2. 完成項目流程

配置環境，使用 envirnment.yml 文件配置名為 robot-env 的 conda 環境，具體而言，你只需轉到當前的目錄，在命令行/終端中運行如下代碼，稍作等待即可。
```
conda env create -f envirnment.yml
```
安裝完畢后，在命令行/終端中運行 source activate robot-env（Mac/Linux 系統）或 activate robot-env（Windows 系統）激活該環境。
閱讀 main.ipynb 中的指導完成項目，並根據指導修改對應的代碼，生成、觀察結果。
導出代碼與報告，上傳文件，提交審閱並優化。

Section 1 算法理解

1. 1 強化學習總覽

強化學習作為機器學習算法的一種，其模式也是讓智能體在“訓練”中學到“經驗”，以實現給定的任務。但不同於監督學習與非監督學習，在強化學習的框架中，我們更側重通過智能體與環境的交互來學習。通常在監督學習和非監督學習任務中，智能體往往需要通過給定的訓練集，輔之以既定的訓練目標（如最小化損失函數），通過給定的學習算法來實現這一目標。然而在強化學習中，智能體則是通過其與環境交互得到的獎勵進行學習。這個環境可以是虛擬的（如虛擬的迷宮），也可以是真實的（自動駕駛汽車在真實道路上收集數據）。

在強化學習中有五個核心組成部分，它們分別是：環境（Environment）、智能體（Agent）、狀態（State）、動作（Action）和獎勵（Reward）。在某一時間節點 $t$

智能體在從環境中感知其所處的狀態 $s_{t}$
智能體根據某些准則選擇動作 $a_{t}$
環境根據智能體選擇的動作，向智能體反饋獎勵 $r_{t + 1}$

通過合理的學習算法，智能體將在這樣的問題設置下，成功學到一個在狀態 $s_{t}$

問題 1：請參照如上的定義，描述出 “機器人走迷宮這個問題” 中強化學習五個組成部分對應的實際對象：

環境 : 迷宮，包括牆壁、陷阱、終點
狀態 : 機器人的位置

動作 : 向上走、向下走、向左走、向右走
獎勵 : 撞到牆壁：-10；走到終點：50；走到陷阱：-30；其余情況：-0.1

1.2 計算 Q 值

在我們的項目中，我們要實現基於 Q-Learning 的強化學習算法。Q-Learning 是一個值迭代（Value Iteration）算法。與策略迭代（Policy Iteration）算法不同，值迭代算法會計算每個”狀態“或是”狀態-動作“的值（Value）或是效用（Utility），然后在執行動作的時候，會設法最大化這個值。因此，對每個狀態值的准確估計，是我們值迭代算法的核心。通常我們會考慮最大化動作的長期獎勵，即不僅考慮當前動作帶來的獎勵，還會考慮動作長遠的獎勵。

在 Q-Learning 算法中，我們把這個長期獎勵記為 Q 值，我們會考慮每個 ”狀態-動作“ 的 Q 值，具體而言，它的計算公式為：

q(s_t,a)=R_t+1+γ×max_aq(a,s_t+1)

也就是對於當前的“狀態-動作” $(s_{t}, a)$

不過一般地，我們使用更為保守地更新 Q 表的方法，即引入松弛變量 $a l p h a$

問題 2：根據已知條件求 $q (s_{t}, a)$

已知：如上圖，機器人位於 $s_{1}$

1.3 如何選擇動作

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

在初步的學習中，我們的 Q 值會不准確，如果在這個時候都按照 Q 值來選擇，那么會造成錯誤。
學習一段時間后，機器人的路線會相對固定，則機器人無法對環境進行有效的探索。

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

問題 3：在如下的代碼塊中，實現 epsilon-greedy 算法的邏輯，並運行測試代碼。

import random 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) > epsilon: # 以某一概率
        action = random.choice(actions) # 實現對動作的隨機選擇
    else: action = max(qline, key=qline.get) # 否則選擇具有最大 Q 值的動作
    return action choose_action(epsilon)

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 之間。

問題 4：在如下的代碼塊中，創建你的迷宮並展示。

from Maze import Maze %matplotlib inline %config InlineBackend.figure_format = 'retina'

## todo: 創建迷宮並展示
 g = Maze(maze_size=(12,12), trap_number=5) g

Maze of size (12, 12)

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

maze.sense_robot() 為一個無參數的函數，輸出機器人在迷宮中目前的位置。
maze.move_robot(direction) 對輸入的移動方向，移動機器人，並返回對應動作的獎勵值。

問題 5：隨機移動機器人，並記錄下獲得的獎勵，展示出機器人最后的位置。

rewards = [] ## 循環、隨機移動機器人10次，記錄下獎勵
for i in range(10): rewards.append(g.move_robot(random.choice(actions))) ## 輸出機器人最后的位置
print(g.sense_robot()) ## 打印迷宮，觀察機器人位置
g

(3, 11)

Maze of size (12, 12)

2.2. `Robot` 類實現

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

首先 Robot 有多個輸入，其中 alpha=0.5, gamma=0.9, epsilon0=0.5 表征強化學習相關的各個參數的默認值，這些在之前你已經了解到，Maze 應為機器人所在迷宮對象。

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

最后你需要實現 Robot.py 代碼中的8段代碼，他們都在代碼中以 #TODO 進行標注，你能輕松地找到他們。

問題 6：實現 Robot.py 中的8段代碼，並運行如下代碼檢查效果（記得將 maze 變量修改為你創建迷宮的變量名）。

from Robot import Robot robot = Robot(g) # 記得將 maze 變量修改為你創建迷宮的變量名
robot.set_status(learning=True,testing=False) print(robot.update()) g

('u', -0.1)

Maze of size (12, 12)

2.3 用 `Runner` 類訓練 Robot

在實現了上述內容之后，我們就可以開始對我們 Robot 進行訓練並調參了。我們為你准備了又一個非常棒的類 Runner，來實現整個訓練過程及可視化。使用如下的代碼，你可以成功對機器人進行訓練。並且你會在當前文件夾中生成一個名為 filename 的視頻，記錄了整個訓練的過程。通過觀察該視頻，你能夠發現訓練過程中的問題，並且優化你的代碼及參數。

問題 7：嘗試利用下列代碼訓練機器人，並進行調參。可選的參數包括：

訓練參數
- 訓練次數 epoch
機器人參數：
- epsilon0 (epsilon 初值)
- epsilon衰減（可以是線性、指數衰減，可以調整衰減的速度），你需要在 Robot.py 中調整
- alpha
- gamma
迷宮參數:
- 迷宮大小
- 迷宮中陷阱的數量

## 可選的參數：
epoch = 20 epsilon0 = 0.3 alpha = 0.5 gamma = 0.9 maze_size = (6,6) trap_number = 1

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") # 你可以注釋該行代碼，加快運行速度，不過你就無法觀察到視頻了。

使用 runner.plot_results() 函數，能夠打印機器人在訓練過程中的一些參數信息。

Success Times 代表機器人在訓練過程中成功的累計次數，這應當是一個累積遞增的圖像。
Accumulated Rewards 代表機器人在每次訓練 epoch 中，獲得的累積獎勵的值，這應當是一個逐步遞增的圖像。
Running Times per Epoch 代表在每次訓練 epoch 中，小車訓練的次數（到達終點就會停止該 epoch 轉入下次訓練），這應當是一個逐步遞減的圖像。

問題 8：使用 runner.plot_results() 輸出訓練結果，根據該結果對你的機器人進行分析。

指出你選用的參數如何，選用參數的原因。
建議你比較不同參數下機器人的訓練的情況。
訓練的結果是否滿意，有何改進的計划。

runner.plot_results()

runner.plot_results()

runner.plot_results()

選用的參數： epoch=20，訓練次數如果太少，有可能機器人永遠無法成功走到終點； epsilon0=0.5，較大的初始值使得機器人在剛開始的時候嘗試更多的可能性； alpha=0.5，權衡上一次學到結果和這一次學習結果，這里取它們的均值； gamma=0.9，充分地對外來獎勵進行考慮，如果取值較小，機器人可能無法學習到一個到達終點的策略； maze_size=(6,6)，迷宮太大，需要的訓練次數需要增加，機器人每次得到的獎勵將減少； trap_number=1，陷阱過多會減少機器人得到的獎勵。對訓練的結果比較滿意；改進計划：增加epoch的值；減小epsilon0的值；

Robot.py

import random 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 exceuting 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.9 

        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.
        if state in self.Qtable: pass
        else: self.Qtable[state] = {'u':0.0, 'r':0.0, 'd':0.0, 'l':0.0} 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) < 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], key=self.Qtable[self.state].get) elif self.testing: # TODO 7. choose action with highest q value
            return max(self.Qtable[self.state], key=self.Qtable[self.state].get) 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] += self.alpha * (r + self.gamma * float(max(self.Qtable[next_state].values()) - self.Qtable[self.state][action])) 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

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。