強化學習算法 Policy Gradient 解決 CartPole 問題，代碼逐條詳解

本文內容源自百度強化學習 7 日入門課程學習整理
感謝百度 PARL 團隊李科澆老師的課程講解

強化學習算法 DQN 解決 CartPole 問題，移動小車使得車上的擺杆保持直立。

• 這個遊戲環境可以說是強化學習中的 “Hello World”

• 大部分的算法都可以先利用這個環境來測試下是否可以收斂

環境介紹：

小車在一個導軌上，無摩擦地來回移動，車上有一根杆子，可以繞着小車上的一個點旋轉，所以我們要做的是，通過推動小車往左或者往右，來確保杆子不倒

終止條件：

• 杆子角度大於 +/-12度
• 車子位移大於 +/-2.4（車子移出了界面外）
• Episode 超出 200 steps

獎勵：

• 每執行一個 step 拿到 1分
• 所以最高是 200 分

環境重置 env.reset()

• 返回狀態值：[小車的位置，小車的速度，杆子的角度，杆子頂端的速度]

每走一步 env.step(0)

• 返回：[當前狀態，獎勵，是否結束]

一、安裝依賴

!pip install gym
!pip install paddlepaddle==1.6.3
!pip install parl==1.3.1

檢查版本是否正確：

# 檢查依賴包版本是否正確
!pip list | grep paddlepaddle
!pip list | grep parl

二、導入依賴

import os
import gym
import numpy as np

import paddle.fluid as fluid
import parl
from parl import layers
from parl.utils import logger

三、設置超參數

LEARNING_RATE = 1e-3 # 0.001

四、搭建Model、Algorithm、Agent架構

Agent把產生的數據傳給algorithm，algorithm根據model的模型結構計算出Loss，使用SGD或者其他優化器不斷的優化，PARL這種架構可以很方便的應用在各類深度強化學習問題中。

4.1 Model

Model用來定義前向(Forward)網絡，用戶可以自由的定製自己的網絡結構。

class Model(parl.Model):
    def __init__(self, act_dim):
        act_dim = act_dim # 動作維度
        hid1_size = act_dim * 10 # 節點數量設置爲 動作維度 的 10 倍

        self.fc1 = layers.fc(size=hid1_size, act='tanh') # 隱藏層用 “tanh” 作爲激活（輸出 -1～1）
        self.fc2 = layers.fc(size=act_dim, act='softmax') # 輸出層用 softmax，即不同動作的概率

    def forward(self, obs):  # 可直接用 model = Model(5); model(obs)調用
        out = self.fc1(obs)
        out = self.fc2(out)
        return out

4.2 Algorithm

Algorithm 定義了具體的算法來更新前向網絡(Model)，也就是通過定義損失函數來更新Model，和算法相關的計算都放在algorithm中。

# from parl.algorithms import PolicyGradient # 也可以直接從parl庫中導入PolicyGradient算法，無需重複寫算法

class PolicyGradient(parl.Algorithm):
    def __init__(self, model, lr=None):
        """ Policy Gradient algorithm
        
        Args:
            model (parl.Model): policy的前向網絡.
            lr (float): 學習率.
        """

        self.model = model # 傳入模型
        assert isinstance(lr, float) # 判定變量類型
        self.lr = lr # 賦值

    def predict(self, obs):
        """ 使用policy model預測輸出的動作概率
        """
        return self.model(obs) # 輸入狀態，輸出各種動作的執行概率

    def learn(self, obs, action, reward):
        """ 用policy gradient 算法更新policy model
        """
        act_prob = self.model(obs)  # 獲取輸出動作概率
        # log_prob = layers.cross_entropy(act_prob, action) # 交叉熵
        # 這裏要用交叉熵作爲損失函數
        # 下面這個沒有直接調用，而是用了原始的交叉熵的計算公式
        log_prob = layers.reduce_sum(
            -1.0 * layers.log(act_prob) * layers.one_hot( # 要轉成 one-hot 向量
                action, act_prob.shape[1]),
            dim=1)
        cost = log_prob * reward # 乘以 reward（未來總收益）
        cost = layers.reduce_mean(cost) # 求每一步的均值

        optimizer = fluid.optimizer.Adam(self.lr) # 使用 Adam 優化器
        optimizer.minimize(cost) # 優化，最小化 cost，即讓最優 action 選擇的概率逼近 1
        return cost

4.3 Agent

Agent負責算法與環境的交互，在交互過程中把生成的數據提供給Algorithm來更新模型(Model)，數據的預處理流程也一般定義在這裏。

class Agent(parl.Agent):
    def __init__(self, algorithm, obs_dim, act_dim):
        self.obs_dim = obs_dim
        self.act_dim = act_dim
        super(Agent, self).__init__(algorithm)

    def build_program(self):
        self.pred_program = fluid.Program()
        self.learn_program = fluid.Program()

        with fluid.program_guard(self.pred_program):  # 搭建計算圖用於 預測動作，定義輸入輸出變量
            # 這個計算圖中，obs 爲輸入
            obs = layers.data(
                name='obs', shape=[self.obs_dim], dtype='float32')
            # 動作的概率爲輸出
            self.act_prob = self.alg.predict(obs)

        with fluid.program_guard(
                self.learn_program):  # 搭建計算圖用於 更新policy網絡，定義輸入輸出變量
            # 這個計算圖中，當前狀態 obs ，選擇的動作 action，獲得的獎勵 reward 爲輸入
            obs = layers.data(
                name='obs', shape=[self.obs_dim], dtype='float32')
            act = layers.data(name='act', shape=[1], dtype='int64')
            reward = layers.data(name='reward', shape=[], dtype='float32')
            # 代價函數計算的損失 爲輸出
            self.cost = self.alg.learn(obs, act, reward)

    def sample(self, obs):
        obs = np.expand_dims(obs, axis=0)  # 增加一維維度，這是由於這裏程序以 batch 輸入，單條數據需要增加一個維度
        # 執行計算圖，獲得動作概率
        act_prob = self.fluid_executor.run(
            self.pred_program, # 輸入搭建的計算圖
            feed={'obs': obs.astype('float32')}, # 輸入的數據
            fetch_list=[self.act_prob])[0] # 最後的取值
        act_prob = np.squeeze(act_prob, axis=0)  # 同樣，程序的輸出數據格式，也需要減少一維維度
        act = np.random.choice(range(self.act_dim), p=act_prob)  # 根據動作概率選取動作
        return act # 概率越高的動作越可能被選到

    def predict(self, obs):
        obs = np.expand_dims(obs, axis=0)
        act_prob = self.fluid_executor.run(
            self.pred_program,
            feed={'obs': obs.astype('float32')},
            fetch_list=[self.act_prob])[0]
        act_prob = np.squeeze(act_prob, axis=0)
        act = np.argmax(act_prob)  # 根據動作概率選擇概率最高的動作
        # 這個要看具體問題，如果是確定性高的問題，比如這裏的 CarPole問題，就可以選擇確定性高的最高概率動作
        return act # 只選擇概率最高的動作

    def learn(self, obs, act, reward):
        act = np.expand_dims(act, axis=-1) # 
        # 指定輸入數據及其類型
        feed = {
            'obs': obs.astype('float32'),
            'act': act.astype('int64'),
            'reward': reward.astype('float32')
        }
        # 運行學習程序，並獲取 cost
        cost = self.fluid_executor.run(
            self.learn_program, feed=feed, fetch_list=[self.cost])[0]
        return cost

五、Training && Test（訓練&&測試）

def run_episode(env, agent):
    obs_list, action_list, reward_list = [], [], [] # 初始化 3 個空的列表
    obs = env.reset() # 重置環境，獲得最初的狀態 obs
    while True:
        obs_list.append(obs) # 爲狀態列表添加狀態
        action = agent.sample(obs) # 採樣動作
        action_list.append(action) # 爲動作列表添加動作

        obs, reward, done, info = env.step(action) # 執行一次交互
        reward_list.append(reward) # 爲獎勵列表添加得到的獎勵

        if done:
            break
    return obs_list, action_list, reward_list

# 評估 agent, 跑 5 個episode，總reward求平均
def evaluate(env, agent, render=False):
    eval_reward = []
    for i in range(5):
        obs = env.reset()
        episode_reward = 0
        while True:
            action = agent.predict(obs) # 選取最優動作
            obs, reward, isOver, _ = env.step(action)
            episode_reward += reward
            if render:
                env.render()
            if isOver:
                break
        eval_reward.append(episode_reward)
    return np.mean(eval_reward)

六、創建環境和Agent，啓動訓練，保存模型

# 根據一個episode的每個step的reward列表，計算每一個Step的Gt
def calc_reward_to_go(reward_list, gamma=1.0):
    for i in range(len(reward_list) - 2, -1, -1):
        # G_t = r_t + γ·r_t+1 + ... = r_t + γ·G_t+1
        reward_list[i] += gamma * reward_list[i + 1]  # 逆向方式求每一步 step 的未來總收益
    return np.array(reward_list)


# 創建環境
env = gym.make('CartPole-v0') # 使用 gym 庫創建環境
obs_dim = env.observation_space.shape[0] # 獲取環境狀態維度
act_dim = env.action_space.n # 獲取動作維度
logger.info('obs_dim {}, act_dim {}'.format(obs_dim, act_dim)) # 打印 log 信息

# 根據parl框架構建agent
model = Model(act_dim=act_dim) # model 實例化
alg = PolicyGradient(model, lr=LEARNING_RATE) # 算法實例化
agent = Agent(alg, obs_dim=obs_dim, act_dim=act_dim) # agent 實例化，傳入了 實例化的 alg 作爲參數

# 加載模型
# if os.path.exists('./model.ckpt'):
#     agent.restore('./model.ckpt')
#     run_episode(env, agent, train_or_test='test', render=True)
#     exit()

for i in range(1000):
    obs_list, action_list, reward_list = run_episode(env, agent) # 每個 episode 記錄下 3 個列表
    if i % 10 == 0: # 每 10 局打印一下 log
        logger.info("Episode {}, Reward Sum {}.".format(
            i, sum(reward_list)))

    batch_obs = np.array(obs_list) # 轉化爲 numpy 數組
    batch_action = np.array(action_list)
    batch_reward = calc_reward_to_go(reward_list) # 調用函數，把單步的收益轉化爲該步的未來總收益

    agent.learn(batch_obs, batch_action, batch_reward) # 獲得一整個 episode 的數據後，學習一次
    if (i + 1) % 100 == 0: # 每 100 局測試一下
        total_reward = evaluate(env, agent, render=False) # render=True 查看渲染效果
        # 這裏設定評估 5 個 episode 取平均結果
        logger.info('Test reward: {}'.format(total_reward))

# 保存模型到文件 ./model.ckpt
agent.save('./model.ckpt')