動手實踐丨基于ModelAtrs使用A2C演算法制作登月器著陸小游戲-有解無憂

摘要：在本案例中，我們將展示如何基于A2C演算法，訓練一個LunarLander小游戲，

本文分享自華為云社區《使用A2C演算法控制登月器著陸》，作者：HWCloudAI ，

LunarLander是一款控制類的小游戲，也是強化學習中常用的例子，游戲任務為控制登月器著陸，玩家通過操作登月器的主引擎和副引擎，控制登月器降落，登月器平穩著陸會得到相應的獎勵積分，如果精準降落在著陸平臺上會有額外的獎勵積分；相反地如果登月器墜毀會扣除積分，

A2C全稱為Advantage Actor-Critic，在本案例中，我們將展示如何基于A2C演算法，訓練一個LunarLander小游戲，

整體流程：基于gym創建LunarLander環境->構建A2C演算法->訓練->推理->可視化效果

A2C演算法的基本結構

A2C是openAI在實作baseline程序中提出的，是一種結合了Value-based (比如 Q learning) 和 Policy-based (比如 Policy Gradients) 的強化學習演算法，

Actor目的是學習策略函式π(θ)以得到盡量高的回報， Critic目的是對當前策略的值函式進行估計，來評價，

Policy Gradients

Policy Gradient演算法的整個程序可以看作先通過策略π(θ)讓agent與環境進行互動，計算每一步所能得到的獎勵，并以此得到一局游戲的獎勵作為累積獎勵G，然后通過調整策略π，使得G最大化，所以使用了梯度提升的方法來更新網路引數θ，利用更新后的策略再采集資料，再更新，如此回圈，達到優化策略的目的，

Actor Critic

agent在于環境互動程序中產生的G值本身是一個隨機變數，可以通過Q函式去估計G的期望值，來增加穩定性，即Actor-Critic演算法在PG策略的更新程序中使用Q函式來代替了G，同時構建了Critic網路來計算Q函式，此時Actor相關引數的梯度為：

而Critic的損失函式使用Q估計和Q實際值差的平方損失來表示：

A2C演算法

A2C在AC演算法的基礎上使用狀態價值函式給Q值增加了基線V，使反饋可以為正或者為負，因此Actor的策略梯變為：

同時Critic網路的損失函式使用實際狀態價值和估計狀態價值的平方損失來表示：

LunarLander-v2游戲環境簡介

LunarLander-v2，是基于gym和box2d提供的游戲環境，游戲任務為玩家通過操作登月器的噴氣主引擎和副引擎來控制登月器降落，

gym:開源強化學習python庫，提供了演算法和環境互動的標準API，以及符合該API的標準環境集，

box2d:gym提供的一種環境集合

注意事項

本案例運行環境為 TensorFlow-1.13.1，且需使用 GPU 運行，請查看《ModelAtrs JupyterLab 硬體規格使用指南》了解切換硬體規格的方法；
如果您是第一次使用 JupyterLab，請查看《ModelAtrs JupyterLab使用指導》了解使用方法；
如果您在使用 JupyterLab 程序中碰到報錯，請參考《ModelAtrs JupyterLab常見問題解決辦法》嘗試解決問題，

實驗步驟

1. 程式初始化

第1步：安裝基礎依賴

要確保所有依賴都安裝成功后，再執行之后的代碼，如果某些模塊因為網路原因導致安裝失敗，直接重試一次即可，

!pip install gym
!conda install swig -y
!pip install box2d-py
!pip install gym[box2d]

第2步：匯入相關的庫

import os
import gym
import numpy as np
import tensorflow as tf
import pandas as pd

2. 引數設定?

本案例設定的游戲最大局數 MAX_EPISODE = 100，保存模型的局數 SAVE_EPISODES = 20，以便快速跑通代碼，

你也可以調大 MAX_EPISODE 和 SAVE_EPISODES 的值，如1000和100，可以達到較好的訓練效果，訓練耗時約20分鐘，

MAX_EPISODE = 100 # 游戲最大局數
DISPLAY_REWARD_THRESHOLD = 100 # 開啟可視化的reward閾值
SAVE_REWARD_THRESHOLD = 100 # 保存模型的reward閾值
MAX_EP_STEPS = 2000 # 每局最大步長
TEST_EPISODE = 10 # 測驗局
RENDER = False # 是否啟用可視化（耗時）
GAMMA = 0.9 # TD error中reward衰減系數
RUNNING_REWARD_DECAY=0.95 # running reward 衰減系數
LR_A = 0.001 # Actor網路的學習率
LR_C = 0.01 # Critic網路學習率
NUM_UNITS = 20 # FC層神經元個數
SEED = 1 # 種子數，減小隨機性
SAVE_EPISODES = 20 # 保存模型的局數
model_dir = './models' # 模型保存路徑

3. 游戲環境創建

def create_env():
    env = gym.make('LunarLander-v2')
 # 減少隨機性
 env.seed(SEED)
    env = env.unwrapped
 num_features = env.observation_space.shape[0]
 num_actions = env.action_space.n
 return env, num_features, num_actions

4. Actor-Critic網路構建?

class Actor:
 """
    Actor網路
    Parameters
    ----------
 sess : tensorflow.Session()
 n_features : int
 特征維度
 n_actions : int
 動作空間大小
 lr : float
 學習率大小
    """
 def __init__(self, sess, n_features, n_actions, lr=0.001):
 self.sess = sess
 # 狀態空間
 self.s = tf.placeholder(tf.float32, [1, n_features], "state")
 # 動作空間
 self.a = tf.placeholder(tf.int32, None, "action")
 # TD_error
 self.td_error = tf.placeholder(tf.float32, None, "td_error")
 # actor網路為兩層全連接層，輸出為動作概率
 with tf.variable_scope('Actor'):
            l1 = tf.layers.dense(
                inputs=self.s,
                units=NUM_UNITS,
                activation=tf.nn.relu,
 kernel_initializer=tf.random_normal_initializer(0., .1),
 bias_initializer=tf.constant_initializer(0.1),
                name='l1'
 )
 self.acts_prob = tf.layers.dense(
                inputs=l1,
                units=n_actions,
                activation=tf.nn.softmax,
 kernel_initializer=tf.random_normal_initializer(0., .1),
 bias_initializer=tf.constant_initializer(0.1),
                name='acts_prob'
 )
 with tf.variable_scope('exp_v'):
 log_prob = tf.log(self.acts_prob[0, self.a])
 # 損失函式
 self.exp_v = tf.reduce_mean(log_prob * self.td_error)
 with tf.variable_scope('train'):
 # minimize(-exp_v) = maximize(exp_v)
 self.train_op = tf.train.AdamOptimizer(lr).minimize(-self.exp_v)
 def learn(self, s, a, td):
        s = s[np.newaxis, :]
 feed_dict = {self.s: s, self.a: a, self.td_error: td}
        _, exp_v = self.sess.run([self.train_op, self.exp_v], feed_dict)
 return exp_v
 # 生成動作
 def choose_action(self, s):
        s = s[np.newaxis, :]
        probs = self.sess.run(self.acts_prob, {self.s: s}) 
 return np.random.choice(np.arange(probs.shape[1]), p=probs.ravel())
class Critic:
 """
    Critic網路
    Parameters
    ----------
 sess : tensorflow.Session()
 n_features : int
 特征維度
 lr : float
 學習率大小
    """
 def __init__(self, sess, n_features, lr=0.01):
 self.sess = sess
 # 狀態空間
 self.s = tf.placeholder(tf.float32, [1, n_features], "state")
 # value值 
 self.v_ = tf.placeholder(tf.float32, [1, 1], "v_next")
 # 獎勵 
 self.r = tf.placeholder(tf.float32, None, 'r')
 # critic網路為兩層全連接層，輸出為value值
 with tf.variable_scope('Critic'):
            l1 = tf.layers.dense(
                inputs=self.s,
 # number of hidden units
                units=NUM_UNITS,
                activation=tf.nn.relu, 
 kernel_initializer=tf.random_normal_initializer(0., .1), 
 bias_initializer=tf.constant_initializer(0.1), 
                name='l1'
 )
 self.v = tf.layers.dense(
                inputs=l1,
 # output units
                units=1,
                activation=None,
 kernel_initializer=tf.random_normal_initializer(0., .1), 
 bias_initializer=tf.constant_initializer(0.1), 
                name='V'
 )
 with tf.variable_scope('squared_TD_error'):
 self.td_error = self.r + GAMMA * self.v_ - self.v
 # TD_error = (r+gamma*V_next) - V_eval
 self.loss = tf.square(self.td_error)
 with tf.variable_scope('train'):
 self.train_op = tf.train.AdamOptimizer(lr).minimize(self.loss)
 def learn(self, s, r, s_):
        s, s_ = s[np.newaxis, :], s_[np.newaxis, :]
        v_ = self.sess.run(self.v, {self.s: s_})
 td_error, _ = self.sess.run([self.td_error, self.train_op],
 {self.s: s, self.v_: v_, self.r: r})
 return td_error

5. 創建訓練函式

def model_train():
    env, num_features, num_actions = create_env()
    render = RENDER
 sess = tf.Session()
    actor = Actor(sess, n_features=num_features, n_actions=num_actions, lr=LR_A)
    critic = Critic(sess, n_features=num_features, lr=LR_C)
 sess.run(tf.global_variables_initializer())
    saver = tf.train.Saver()
 for i_episode in range(MAX_EPISODE+1):
 cur_state = env.reset()
 cur_step = 0
 track_r = []
 while True:
 # notebook暫不支持該游戲的可視化
 # if RENDER:
 # env.render()
            action = actor.choose_action(cur_state)
 next_state, reward, done, info = env.step(action)
 track_r.append(reward)
 # gradient = grad[reward + gamma * V(next_state) - V(cur_state)]
 td_error = critic.learn(cur_state, reward,
 next_state)
 # true_gradient = grad[logPi(cur_state,action) * td_error]
 actor.learn(cur_state, action, td_error) 
 cur_state = next_state
 cur_step += 1
 if done or cur_step >= MAX_EP_STEPS:
 ep_rs_sum = sum(track_r)
 if 'running_reward' not in locals():
 running_reward = ep_rs_sum
 else:
 running_reward = running_reward * RUNNING_REWARD_DECAY + ep_rs_sum * (1-RUNNING_REWARD_DECAY)
 # 判斷是否達到可視化閾值
 # if running_reward > DISPLAY_REWARD_THRESHOLD:
 #     render = True
 print("episode:", i_episode, "  reward:", int(running_reward), "  steps:", cur_step)
 break
 if i_episode > 0 and i_episode % SAVE_EPISODES == 0:
 if not os.path.exists(model_dir):
 os.mkdir(model_dir)
 ckpt_path = os.path.join(model_dir, '{}_model.ckpt'.format(i_episode))
 saver.save(sess, ckpt_path)

6. 開始訓練

訓練一個episode大約需1.2秒

print('MAX_EPISODE:', MAX_EPISODE)
model_train()
# reset graph
tf.reset_default_graph()

7.使用模型推理

由于本游戲內核可視化依賴于OpenGL，需要桌面化作業系統的視窗顯示，但當前環境暫不支持彈窗，因此無法可視化，您可將代碼下載到本地，取消 env.render() 這行代碼的注釋，查看可視化效果，

def model_test():
    env, num_features, num_actions = create_env()
 sess = tf.Session()
    actor = Actor(sess, n_features=num_features, n_actions=num_actions, lr=LR_A)
 sess.run(tf.global_variables_initializer())
    saver = tf.train.Saver()
 saver.restore(sess, tf.train.latest_checkpoint(model_dir))
 for i_episode in range(TEST_EPISODE):
 cur_state = env.reset()
 cur_step = 0
 track_r = []
 while True:
 # 可視化
 # env.render()
            action = actor.choose_action(cur_state)
 next_state, reward, done, info = env.step(action)
 track_r.append(reward)
 cur_state = next_state
 cur_step += 1
 if done or cur_step >= MAX_EP_STEPS:
 ep_rs_sum = sum(track_r)
 print("episode:", i_episode, "  reward:", int(ep_rs_sum), "  steps:", cur_step)
 break
model_test()
episode: 0   reward: -31   steps: 196
episode: 1   reward: -99   steps: 308
episode: 2   reward: -273   steps: 533
episode: 3   reward: -5   steps: 232
episode: 4   reward: -178   steps: 353
episode: 5   reward: -174   steps: 222
episode: 6   reward: -309   steps: 377
episode: 7   reward: 24   steps: 293
episode: 8   reward: -121   steps: 423
episode: 9   reward: -194   steps: 286

8.可視化效果

下面的視頻為訓練1000 episode模型的推理效果，該視頻演示了在三個不同的地形情況下，登月器都可以安全著陸

https://modelarts-labs-bj4-v2.obs.cn-north-4.myhuaweicloud.com/course/modelarts/reinforcement_learning/a2c_lunarlander/A2C_lunarlander.mp4

點擊關注，第一時間了解華為云新鮮技術~

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/538176.html

標籤：其他

上一篇：例外值檢測！最佳統計方法實踐（代碼實作）！?

下一篇：處理器基礎知識