本文內容源自百度強化學習 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

二、導入依賴

import parl
from parl import layers
# parl 封裝了 paddle.fluid.layers 的 API，官網可查詢使用方式
import paddle.fluid as fluid
import copy
import numpy as np
import os
import gym
from parl.utils import logger

三、設置超參數

LEARN_FREQ = 5 # 訓練頻率，不需要每一個step都learn，攢一些新增經驗後再learn，提高效率
MEMORY_SIZE = 20000    # replay memory的大小，越大越佔用內存
MEMORY_WARMUP_SIZE = 200  # replay_memory 裏需要預存一些經驗數據，再開啓訓練
BATCH_SIZE = 32   # 每次給agent learn的數據數量，從replay memory隨機裏sample一批數據出來
LEARNING_RATE = 0.001 # 學習率
GAMMA = 0.99 # reward 的衰減因子，一般取 0.9 到 0.999 不等

四、Model

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

class Model(parl.Model):
  # 這裏的 model 利用 parl.Model 作爲基類，後面會用到一些基類下的方法
    def __init__(self, act_dim):
        hid1_size = 128
        hid2_size = 128
        # 3層全連接網絡
        self.fc1 = layers.fc(size=hid1_size, act='relu')
        self.fc2 = layers.fc(size=hid2_size, act='relu')
        self.fc3 = layers.fc(size=act_dim, act=None)

    def value(self, obs):
        # 定義網絡
        # 輸入state，輸出所有action對應的Q，[Q(s,a1), Q(s,a2), Q(s,a3)...]
        h1 = self.fc1(obs)
        h2 = self.fc2(h1)
        Q = self.fc3(h2)
        return Q # 輸出的 Q 是一個向量，維度是動作的維度

五、Algorithm

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

這裏的核心是 learn() 函數，其中分爲 3 部分：

獲取 Q 目標值
- 注意點：在 target_Q 的計算中，有個判斷條件，是否遊戲結束，計算公式不同
  - terminal：即是否爲 done，是的話爲 true（1），否的話爲 false（0）
  - 所以用 $(1.0-terminal)$ 作爲係數就可以達到 “判斷” 語句的效果（之前要先用 layers.cast 將 terminal 轉化爲浮點數）
- 注意點：best_v.stop_gradient = True 阻止梯度傳遞
  - 我們在通過神經網絡獲得 target_Q 的時候，並不希望去更新 target_model 神經網絡參數，所以要阻止梯度傳遞
獲取 Q 預測值
- 注意點：從 Q 值列表中取得對應動作的 Q 值
  - 首先把 action 轉爲 one-hot 向量
  - 然後用兩個向量元素相乘的方法 layers.elementwise_mul 只保留對應的值，其他變爲 0
  - 然後用元素累加的方法 layers.reduce_sum 就得到了最終的值（這裏是 “第 2 維” 的累加，所以 dim=1）
計算 loss

這裏 learn() 函數的輸入 obs, action, reward, next_obs, terminal

由於每次傳入一個 batch ，所以每一個參數都是一個數組

# from parl.algorithms import DQN # 也可以直接從parl庫中導入DQN算法

class DQN(parl.Algorithm):
    def __init__(self, model, act_dim=None, gamma=None, lr=None):
        """ DQN algorithm
        
        Args:
            model (parl.Model): 定義Q函數的前向網絡結構
            act_dim (int): action空間的維度，即有幾個action
            gamma (float): reward的衰減因子
            lr (float): learning rate 學習率.
        """
        self.model = model # 傳入之前定義好的 model 結構
        self.target_model = copy.deepcopy(model) # 把模型硬拷貝一份，作爲 target_model（固定）

        assert isinstance(act_dim, int) # 斷言，確認動作維度，是 int
        assert isinstance(gamma, float) # 斷言，確認衰減因子，是 float
        assert isinstance(lr, float) # 斷言，確定學習速率，是 float
        self.act_dim = act_dim  #傳入
        self.gamma = gamma #傳入
        self.lr = lr #傳入

    def predict(self, obs):
        """ 使用self.model的value網絡來獲取 [Q(s,a1),Q(s,a2),...]
        """
        return self.model.value(obs) # 把 obs 傳入前向網絡，得到當前狀態下，所有可執行動作的 Q 值（預測值）

    def learn(self, obs, action, reward, next_obs, terminal):
        """ 使用DQN算法更新self.model的value網絡
        """
        # 1. 從target_model中獲取 max Q' 的值，用於計算target_Q（目標值）
        next_pred_value = self.target_model.value(next_obs) 
        # 獲得下一步狀態下，所以可執行動作的 Q 值
        best_v = layers.reduce_max(next_pred_value, dim=1)
        # 求最大 Q 值
        best_v.stop_gradient = True  # 阻止梯度傳遞
        terminal = layers.cast(terminal, dtype='float32')
        # 把 terminal 轉化爲 float32 類型
        target = reward + (1.0 - terminal) * self.gamma * best_v
        # 

        # 2. 獲取 Q （預測值）
        pred_value = self.model.value(obs) # 正向傳播，即獲得了該狀態下，所有動作對應的 Q 值         
        # 將action轉onehot向量，比如：3 => [0,0,0,1,0]
        action_onehot = layers.one_hot(action, self.act_dim)
        # 輸入的動作值，比如 4，根據 depth 即動作維度，轉化爲對應的 one-hot
        action_onehot = layers.cast(action_onehot, dtype='float32')
        # 設定 one-hot 中的值爲 float32 類型
        
        # 下面一行是逐元素相乘，拿到action對應的 Q(s,a)
        # 比如：pred_value = [[2.3, 5.7, 1.2, 3.9, 1.4]], action_onehot = [[0,0,0,1,0]]
        #  ==> pred_action_value = [[3.9]]
        pred_action_value = layers.reduce_sum(
            layers.elementwise_mul(action_onehot, pred_value), dim=1)
        # 當前狀態下，執行該 action 得到的 Q 值（預測值）

        # 3. 計算 Q(s,a) 與 target_Q的均方差，得到loss
        cost = layers.square_error_cost(pred_action_value, target)
        # 損失函數爲舊的 Q 和 目標 Q 之間的差別（均方差）
        cost = layers.reduce_mean(cost)
        # 均值
        optimizer = fluid.optimizer.Adam(learning_rate=self.lr)  # 使用Adam優化器
        optimizer.minimize(cost) # 目標是最小化損失函數
        return cost

    def sync_target(self):
        """ 把 self.model 的模型參數值同步到 self.target_model
        """
        self.model.sync_weights_to(self.target_model)
        # 這是 parl.Model 這個基類下的方法，用於定時爲target_model做參數同步

六、Agent

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

這裏 learn() 函數的輸入也是從經驗池中拿到的一個 batch 的數據，然後進行對應的變量賦值
- 變量的定義是在 build_program() 中（計算圖）完成，包括變量的類型 dtype，結構 shape，名字 name
- 然後每執行一次 learn() 就是把數據通過 feed 傳入 program，然後獲取 fetch_list 中的 self.cost
- 每一次執行 run 就是完成了一次網絡的更新
這裏還有一個計算圖 pred_program 用於獲取最大的 Q 值（預測值）下的 action
- 首先通過 predict() 函數，調用 alg 中的 predict() 計算最大的 Q 值
- 然後獲取對應的 action，僅需使用 np.argmax 函數
- 然後通過 sample() 函數決定是利用還是探索，選擇具體執行的動作

class Agent(parl.Agent):
  # 繼承了 parl.Agent 這個基類
  # 其實基類下只有一個 save 和 restore 方法
  # 其他的方法：build_program，learn，predict，sample 都是空的
    def __init__(self,
                 algorithm, # 算法
                 obs_dim, # 狀態的維度
                 act_dim, # 動作的維度
                 e_greed=0.1, # 10% 的隨機探索概率
                 e_greed_decrement=0): # 概率遞減爲 0
        assert isinstance(obs_dim, int) # 斷言，狀態維度，爲 int
        assert isinstance(act_dim, int) # 斷言，動作維度，爲 int
        self.obs_dim = obs_dim # 初始化賦值
        self.act_dim = act_dim # 初始化賦值
        super(Agent, self).__init__(algorithm)
        # 

        self.global_step = 0 # 
        self.update_target_steps = 200  # 每隔200個training steps再把model的參數複製到target_model中

        self.e_greed = e_greed  # 有一定概率隨機選取動作，探索
        self.e_greed_decrement = e_greed_decrement  # 隨着訓練逐步收斂，探索的程度慢慢降低

    def build_program(self):
        self.pred_program = fluid.Program() # 初始化一個 paddle.fluid 框架下的程序
        self.learn_program = fluid.Program() # 初始化一個 paddle.fluid 框架下的程序

        with fluid.program_guard(self.pred_program):  # 搭建計算圖用於 預測動作，定義輸入輸出變量
          # 把下面的語句添加到 self.pred_program 程序中
            obs = layers.data(
                name='obs', shape=[self.obs_dim], dtype='float32')
            # 將 obs 設定爲數據變量
            self.value = self.alg.predict(obs)
            # 

        with fluid.program_guard(self.learn_program):  # 搭建計算圖用於 更新Q網絡，定義輸入輸出變量
          # 把下面的語句添加到 self.learn_program 程序中
            obs = layers.data(
                name='obs', shape=[self.obs_dim], dtype='float32')
            # 將 obs 設定爲數據變量
            action = layers.data(name='act', shape=[1], dtype='int32')
            # 將 action 設定爲數據變量
            reward = layers.data(name='reward', shape=[], dtype='float32')
            # 將 reward 設定爲數據變量
            next_obs = layers.data(
                name='next_obs', shape=[self.obs_dim], dtype='float32')
            # 將 next_obs 設定爲數據變量
            terminal = layers.data(name='terminal', shape=[], dtype='bool')
            # 將 terminal 設定爲數據變量
            self.cost = self.alg.learn(obs, action, reward, next_obs, terminal)
            # 

    def sample(self, obs): # 採樣動作
        sample = np.random.rand()  # 產生0~1之間的小數
        if sample < self.e_greed: # 小於 0.1，即 10% 的概率
            act = np.random.randint(self.act_dim)  # 探索：每個動作都有概率被選擇
        else:
            act = self.predict(obs)  # 選擇最優動作
        self.e_greed = max(
            0.01, self.e_greed - self.e_greed_decrement)  # 隨着訓練逐步收斂，探索的程度慢慢降低
        return act

    def predict(self, obs):  # 選擇最優動作
        obs = np.expand_dims(obs, axis=0) # 將數字轉化爲一維向量
        pred_Q = self.fluid_executor.run(
            self.pred_program,
            feed={'obs': obs.astype('float32')},
            fetch_list=[self.value])[0]
        # 執行定義好的程序，獲取 obs 狀態下的，所有動作的 Q 值
        pred_Q = np.squeeze(pred_Q, axis=0)
        # 壓縮一個維度
        act = np.argmax(pred_Q)  # 選擇Q最大的下標，即對應的動作
        return act

    def learn(self, obs, act, reward, next_obs, terminal):
        # 每隔200個training steps同步一次model和target_model的參數
        if self.global_step % self.update_target_steps == 0:
            self.alg.sync_target()
            #
        self.global_step += 1
        # 步數+1

        act = np.expand_dims(act, -1) # 將數字轉化爲一維向量
        feed = {
            'obs': obs.astype('float32'),
            'act': act.astype('int32'),
            'reward': reward,
            'next_obs': next_obs.astype('float32'),
            'terminal': terminal
        }
        # 定義所有傳入的數據
        cost = self.fluid_executor.run(
            self.learn_program, feed=feed, fetch_list=[self.cost])[0]  # 訓練一次網絡
        return cost

七、ReplayMemory

經驗池：用於存儲多條經驗，實現經驗回放。

import random
import collections
import numpy as np


class ReplayMemory(object):
    def __init__(self, max_size):
        self.buffer = collections.deque(maxlen=max_size)
        # 初始化一個雙向列表，長度爲 max_size

    # 增加一條經驗到經驗池中
    def append(self, exp):
        self.buffer.append(exp)
        # 在列表尾部增加一條經驗

    # 從經驗池中選取N條經驗出來
    def sample(self, batch_size):
        mini_batch = random.sample(self.buffer, batch_size)
        # 從緩存列表中，隨機去除 batch_size 條經驗
        obs_batch, action_batch, reward_batch, next_obs_batch, done_batch = [], [], [], [], []
        # 初始化列表

        for experience in mini_batch:
            s, a, r, s_p, done = experience # 從 mini_batch 中去取得對應元素
            # 加入各自的列表中
            obs_batch.append(s)
            action_batch.append(a)
            reward_batch.append(r)
            next_obs_batch.append(s_p)
            done_batch.append(done)

        # 轉化爲 numpy 的數組進行返回
        return np.array(obs_batch).astype('float32'), \
            np.array(action_batch).astype('float32'), np.array(reward_batch).astype('float32'),\
            np.array(next_obs_batch).astype('float32'), np.array(done_batch).astype('float32')

    def __len__(self):
        return len(self.buffer) # 設定一個參數 len 是緩存的長度

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

訓練的時候，需要先填滿經驗池纔開始

採用 sample 方式，有探索概率

評估的時候，這裏設定爲 5 個 episode 求平均分

這是因爲強化學習有一定不確定性
環境也有隨機選
所以哪怕是一個訓練好的 agent，單次的 episode 的分數也可能特別差/特別好
所以多跑幾組求平均這樣的評估比較客觀

# 訓練一個episode
def run_episode(env, agent, rpm):
    total_reward = 0 # 累計獎勵初始化
    obs = env.reset() # 初始化一個環境，返回值是初始狀態 obs
    step = 0 # 初始化步數
    while True:
        step += 1
        action = agent.sample(obs)  # 採樣動作，所有動作都有概率被嘗試到
        next_obs, reward, done, _ = env.step(action)
        rpm.append((obs, action, reward, next_obs, done))

        # train model
        if (len(rpm) > MEMORY_WARMUP_SIZE) and (step % LEARN_FREQ == 0):
            (batch_obs, batch_action, batch_reward, batch_next_obs,
             batch_done) = rpm.sample(BATCH_SIZE)
            train_loss = agent.learn(batch_obs, batch_action, batch_reward,
                                     batch_next_obs,
                                     batch_done)  # s,a,r,s',done

        total_reward += reward
        obs = next_obs
        if done:
            break
    return total_reward


# 評估 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, done, _ = env.step(action)
            episode_reward += reward
            if render:
                env.render()
            if done:
                break
        eval_reward.append(episode_reward)
    return np.mean(eval_reward)

九、創建環境和Agent，創建經驗池，啓動訓練，保存模型

env = gym.make('CartPole-v0')  # CartPole-v0: 預期最後一次評估總分 > 180（最大值是200）
action_dim = env.action_space.n  # CartPole-v0: 2
obs_shape = env.observation_space.shape  # CartPole-v0: (4,)

rpm = ReplayMemory(MEMORY_SIZE)  # DQN的經驗回放池實例化

# 根據parl框架構建agent
model = Model(act_dim=action_dim) # 模型實例化
algorithm = DQN(model, act_dim=action_dim, gamma=GAMMA, lr=LEARNING_RATE) # 算法實例化（傳入模型）
# agent 實例化（傳入算法）
agent = Agent(
    algorithm,
    obs_dim=obs_shape[0],
    act_dim=action_dim,
    e_greed=0.1,  # 有一定概率隨機選取動作，探索
    e_greed_decrement=1e-6)  # 隨着訓練逐步收斂，探索的程度慢慢降低

# 加載模型
# save_path = './dqn_model.ckpt'
# agent.restore(save_path)

# 先往經驗池裏存一些數據，避免最開始訓練的時候樣本豐富度不夠
while len(rpm) < MEMORY_WARMUP_SIZE: # 當經驗池不滿的時候（這裏小於 200 條）
    run_episode(env, agent, rpm) # 持續添加到經驗池（沒有開始進行訓練）

max_episode = 2000

# 開始訓練
episode = 0
while episode < max_episode:  # 訓練max_episode個回合，test部分不計算入episode數量
    # train part
    for i in range(0, 50):
        total_reward = run_episode(env, agent, rpm)
        episode += 1

    # test part
    eval_reward = evaluate(env, agent, render=False)  # render=True 查看顯示效果
    logger.info('episode:{}    e_greed:{}   test_reward:{}'.format(
        episode, agent.e_greed, eval_reward))

# 訓練結束，保存模型
save_path = './dqn_model.ckpt'
agent.save(save_path)

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

文章目錄

一、安裝依賴

二、導入依賴

三、設置超參數

四、Model

五、Algorithm

六、Agent

七、ReplayMemory

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

九、創建環境和Agent，創建經驗池，啓動訓練，保存模型

十、總結

PDManer [元數建模]-v4.9.0 發佈：一款簡單好用的數據庫建模平臺

使用neovim打造go ide(支持代碼跳轉, 代碼補全, 實時語法檢查)

sql求連續值問題

cs01 CSS Syntax

sql server sp_executesql 中使用表變量進行查詢

挑戰程序設計競賽 2.3章習題 poj 3046 Ant Counting

[MASM拾遺]Offset僞指令

h30 HTML Layout Elements

瞭解顯卡

一款基於C#開發的通訊調試工具（支持Modbus RTU、MQTT調試）

強化學習算法實現自動炒股

C# 異常處理（學習心得 26）

C# 的繼承（學習心得 19）

強化學習算法 DDPG 進行四軸飛行器的速度控制

C# 接口 Interface（學習心得 22）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結