近端策略優(yōu)化算法（Proximal Policy Optimization，簡稱PPO） ，它的性能堪比目前最先進的相關算法，同時極易實現(xiàn)和調參。得益于其優(yōu)異的易用性和超高表現(xiàn)，PPO已經(jīng)成為了OpenAI的默認增強學習算法。

      PPO使得我們可以在相當復雜的環(huán)境中訓練AI的運動策略，比如上面所顯示的 Roboschool 項目，該項目中期望訓練一個機器人（agent）去到達一個目標（場地上的粉球），機器人需要自己去掌握行走、跑動和轉彎等動作，并通過調整自身的動量從輕微擊打（視頻中可以看到飛行的白色小方塊，打到人物模型后模型會晃動甚至倒地。——譯者注）中恢復，以及學習如何在被擊倒之后從地面上重新站起。

      策略梯度算法 是一種很有效的算法，無論是 視頻游戲測試 、 3D運動控制 還是 圍棋AI ，我們在針對這些領域的深度神經(jīng)網(wǎng)絡研究上所獲得的突破都是基于策略梯度算法。但是，企圖通過策略梯度算法來獲得更好的結果是很難的，這是因為這種方法對于步長（stepsize）的選擇很敏感——步長太小，計算過程會慢到令人發(fā)指；而步長太大，信號又很容易被噪聲影響而導致無法收斂，或是可能出現(xiàn)嚴重的性能驟降問題。采用策略梯度算法的采樣效率往往很難令人滿意，我們進場會為了訓練幾個簡單的任務二而耗費成百上千個步長時間。

     學者們期望通過一些方法來修補這些瑕疵，比如通過限制或是優(yōu)化策略更新幅度來提升效率， TRPO 和 ACER 就是一些著名的嘗試。這些方法通常會有它們自定義的權衡方法——ACER需要額外的程序代碼來做off-policy糾正以及經(jīng)驗回放（replay buffer），因而它比PPO復雜得多，而且根據(jù)雅達利評測模型（Atari benchmark）的測試，這種復雜僅僅帶來了些微的優(yōu)勢；而對于TRPO，雖然它對于處理連續(xù)性的控制任務極為有用，但對于一些需要在策略和價值函數(shù)或者輔助損失過程之間傳遞參數(shù)的算法而言，TRPO的兼容性并不理想，而這些算法在解決雅達利問題或是其他主要依賴圖像輸入的問題中相當普遍。

      我們已經(jīng)使用PPO所訓練的運動策略來構建了一些可互動機器人——我們可以在Roboschool提供的環(huán)境中 使用鍵盤 來為機器人設置一些新的目標位置，即使輸入序列與模型的訓練過程并不一致，機器人也能設法完成任務。

     我們同樣使用PPO來訓練一個復雜的仿真機器人學會行走，比如下面的來自波士頓動力學（Boston Dynamics）的亞特蘭斯（'Atlas'）模型。這個模型擁有30個關節(jié)，相對的，上面的人形機器人只有17個關節(jié)。 一些其他的研究者 表示使用PPO訓練的仿真機器人在跨越障礙時甚至會采用一些令人驚訝的跑酷動作。

     相對而言，監(jiān)督學習是很容易的，我們只要實現(xiàn)一個價值函數(shù)，對此采用梯度下降法，幾乎不用做什么進一步的參數(shù)調優(yōu)就能很驕傲地宣稱自己得到了一個很優(yōu)秀的訓練結果�？上У氖�，在增強學習中這一切并不會如此簡單——增強學習的算法有著太多難以調試的可變部分，我們必須花費大把的精力才能得到一個良好的訓練結果。而為了平衡易于實現(xiàn)、樣本復雜度以及易于優(yōu)化這幾個問題，并力求在每一次收斂步驟中都得到策略更新，同時保證與之前的策略偏差相對較小，我們必須尋找一種新的優(yōu)化方法，這就是PPO算法。

import os
import shutil
import time
from time import sleep

from ppo.renderthread import RenderThread
from ppo.models import *
from ppo.trainer import Trainer
from agents import GymEnvironment

# ## Proximal Policy Optimization (PPO)
# Contains an implementation of PPO as described [here](https://arxiv.org/abs/1707.06347).

# Algorithm parameters
# batch-size=<n>           How many experiences per gradient descent update step [default: 64].
batch_size = 128
# beta=<n>                 Strength of entropy regularization [default: 2.5e-3].
beta = 2.5e-3
# buffer-size=<n>          How large the experience buffer should be before gradient descent [default: 2048].
buffer_size = batch_size * 32
# epsilon=<n>              Acceptable threshold around ratio of old and new policy probabilities [default: 0.2].
epsilon = 0.2
# gamma=<n>                Reward discount rate [default: 0.99].
gamma = 0.99
# hidden-units=<n>         Number of units in hidden layer [default: 64].
hidden_units = 128
# lambd=<n>                Lambda parameter for GAE [default: 0.95].
lambd = 0.95
# learning-rate=<rate>     Model learning rate [default: 3e-4].
learning_rate = 4e-5
# max-steps=<n>            Maximum number of steps to run environment [default: 1e6].
max_steps = 15e6
# normalize                Activate state normalization for this many steps and freeze statistics afterwards.
normalize_steps = 0
# num-epoch=<n>            Number of gradient descent steps per batch of experiences [default: 5].
num_epoch = 10
# num-layers=<n>           Number of hidden layers between state/observation and outputs [default: 2].
num_layers = 1
# time-horizon=<n>         How many steps to collect per agent before adding to buffer [default: 2048].
time_horizon = 2048

# General parameters
# keep-checkpoints=<n>     How many model checkpoints to keep [default: 5].
keep_checkpoints = 5
# load                     Whether to load the model or randomly initialize [default: False].
load_model = True
# run-path=<path>          The sub-directory name for model and summary statistics.
summary_path = './PPO_summary'
model_path = './models'
# summary-freq=<n>         Frequency at which to save training statistics [default: 10000].
summary_freq = buffer_size * 5
# save-freq=<n>            Frequency at which to save model [default: 50000].
save_freq = summary_freq
# train                    Whether to train model, or only run inference [default: False].
train_model = False
# render environment to display progress
render = True
# save recordings of episodes
record = True

os.environ["CUDA_VISIBLE_DEVICES"] = "-1"  # GPU is not efficient here

env_name = 'RocketLander-v0'
env = GymEnvironment(env_name=env_name, log_path="./PPO_log", skip_frames=6)
env_render = GymEnvironment(env_name=env_name, log_path="./PPO_log_render", render=True, record=record)
fps = env_render.env.metadata.get('video.frames_per_second', 30)

print(str(env))
brain_name = env.external_brain_names[0]

tf.reset_default_graph()

ppo_model = create_agent_model(env, lr=learning_rate,
                               h_size=hidden_units, epsilon=epsilon,
                               beta=beta, max_step=max_steps,
                               normalize=normalize_steps, num_layers=num_layers)

is_continuous = env.brains[brain_name].action_space_type == "continuous"
use_observations = False
use_states = True

if not load_model:
    shutil.rmtree(summary_path, ignore_errors=True)

if not os.path.exists(model_path):
    os.makedirs(model_path)

if not os.path.exists(summary_path):
    os.makedirs(summary_path)

tf.set_random_seed(np.random.randint(1024))
init = tf.global_variables_initializer()
saver = tf.train.Saver(max_to_keep=keep_checkpoints)

with tf.Session() as sess:
    # Instantiate model parameters
    if load_model:
        print('Loading Model...')
        ckpt = tf.train.get_checkpoint_state(model_path)
        if ckpt is None:
            print('The model {0} could not be found. Make sure you specified the right --run-path'.format(model_path))
        saver.restore(sess, ckpt.model_checkpoint_path)
    else:
        sess.run(init)

    steps, last_reward = sess.run([ppo_model.global_step, ppo_model.last_reward])
    summary_writer = tf.summary.FileWriter(summary_path)
    info = env.reset()[brain_name]
    trainer = Trainer(ppo_model, sess, info, is_continuous, use_observations, use_states, train_model)
    trainer_monitor = Trainer(ppo_model, sess, info, is_continuous, use_observations, use_states, False)
    render_started = False

    while steps <= max_steps or not train_model:
        if env.global_done:
            info = env.reset()[brain_name]
            trainer.reset_buffers(info, total=True)
        # Decide and take an action
        if train_model:
            info = trainer.take_action(info, env, brain_name, steps, normalize_steps, stochastic=True)
            trainer.process_experiences(info, time_horizon, gamma, lambd)
        else:
            sleep(1)
        if len(trainer.training_buffer['actions']) > buffer_size and train_model:
            if render:
                renderthread.pause()
            print("Optimizing...")
            t = time.time()
            # Perform gradient descent with experience buffer
            trainer.update_model(batch_size, num_epoch)
            print("Optimization finished in {:.1f} seconds.".format(float(time.time() - t)))
            if render:
                renderthread.resume()
        if steps % summary_freq == 0 and steps != 0 and train_model:
            # Write training statistics to tensorboard.
            trainer.write_summary(summary_writer, steps)
        if steps % save_freq == 0 and steps != 0 and train_model:
            # Save Tensorflow model
            save_model(sess=sess, model_path=model_path, steps=steps, saver=saver)
        if train_model:
            steps += 1
            sess.run(ppo_model.increment_step)
            if len(trainer.stats['cumulative_reward']) > 0:
                mean_reward = np.mean(trainer.stats['cumulative_reward'])
                sess.run(ppo_model.update_reward, feed_dict={ppo_model.new_reward: mean_reward})
                last_reward = sess.run(ppo_model.last_reward)
        if not render_started and render:
            renderthread = RenderThread(sess=sess, trainer=trainer_monitor,
                                        environment=env_render, brain_name=brain_name, normalize=normalize_steps, fps=fps)
            renderthread.start()
            render_started = True
    # Final save Tensorflow model
    if steps != 0 and train_model:
        save_model(sess=sess, model_path=model_path, steps=steps, saver=saver)
env.close()
export_graph(model_path, env_name)
os.system("shutdown")