1.前言

image
我们有了像Q-learning这么伟大的算法，为什么还要瞎折腾出一个Actor-Critic？原来Actor-Critic的Actor的前生是Policy Gradients，这能让它毫不费力地在连续动作中选择合适的动作，而Q-learning做这件事会瘫痪。那为什么不直接用Policy Gradients呢？原来Actor Critic中的Critic的前生是Q-Learning或其他的以值为基础的学习法，能进行单步更新，而传统的Policy Gradients则是回合更新，这降低了学习效率。

2.算法

2.1 算法剖析

image

我们把算法分成两部分，Actor和Critic，他们都能用不同的神经网络来代替。在Policy Gradient中提到过，现实中的reward会左右Actor的更新情况。Policy Gradients也是靠这个来获取适宜的更新。那么何时会有reward这种信息，而这些信息又能不能被学习呢？这看起来不就是以值为基础的强化学习方法做过的事吗。那我们就拿一个Critic去学习这些奖惩机制，学习完以后，由Actor来指手画脚，由Critic来告诉Actor你的那些指手画脚哪些指的好，哪些指的差，Critic通过学习环境和奖励之间的关系，能看到现在所处状态的潜在奖励，所以用它来指点Actor便能使Actor每一步都在更新，如果使用单纯的Policy Gradients，，Actor只能等到回合结束才能开始更新。

image

但事物总有他坏的一面，Actor-Critic涉及到了两个神经网络，而且每次都是在连续状态中更新参数，每次参数更新前后都存在相关性，导致神经网络只能片面地看待问题，甚至导致神经网络学不到东西。Google DeepMind为了解决这个问题，修改了Actor Critic的算法，将之前在Atari上获得成功的DQN网络加入进Actor Critic系统中，这种新算法叫做 Deep Deterministic Policy Gradient，成功地解决了在连续动作预测上学不到东西的问题，这个算法我们会在下一篇文章介绍。

一句话概括Actor Critic方法：
结合了Policy Gradient(Actor)和Function Approximation(Critic)的方法。Actor基于概率选行为，Critic基于Actor的行为评判行为评判行为的得分，Actor根据Critic的评分修改选行为的概率。

优势:可以进行单步更新，比传统的Policy Gradient要快。
劣势：取决于Critic价值判断，但是Critic难收敛，再加上Actor的更新，就更难收敛。为了解决收敛问题，DeepMind团队融合了DQN的优势，解决了收敛难的问题。

下面是基于Actor Critic的Gym Cartpole实验：

image

这套算法是在普通的Policy Gradient的基础上修改的，如果对Policy Gradient算法那不了解的可以看一下我之前的文章。

Actor修改行为时就像蒙着眼睛一直向前开车，Critic就是那个扶方向盘改变Actor开车方向的。

image
或者说详细点，就是Actor在运用Policy Gradient的方法进行Gradient asent的时候，由Actor来告诉他，这次的Gradient ascent是不是一次正确的ascent，如果这次的得分不好，那么就不要ascent那么多。

2.2 代码

image
上图是Actor的神经网络结果，代码结构在下面：

class Actor(object):
    def __init__(self, sess, n_features, n_actions, lr=0.001):
        # 用 tensorflow 建立 Actor 神经网络,
        # 搭建好训练的 Graph.

    def learn(self, s, a, td):
        # s, a 用于产生 Gradient ascent 的方向,
        # td 来自 Critic, 用于告诉 Actor 这方向对不对.

    def choose_action(self, s):
        # 根据 s 选 行为 a

image
上图是Critic的神经网络结果，代码结果在下面：

class Critic(object):
    def __init__(self, sess, n_features, lr=0.01):
        # 用 tensorflow 建立 Critic 神经网络,
        # 搭建好训练的 Graph.

    def learn(self, s, r, s_):
        # 学习 状态的价值 (state value), 不是行为的价值 (action value),
        # 计算 TD_error = (r + v_) - v,
        # 用 TD_error 评判这一步的行为有没有带来比平时更好的结果,
        # 可以把它看做 Advantage
        return # 学习时产生的 TD_error

Actor想要最大化期望的reward，在Actor Ctitic算法中，我们用“比平时好多少”(TD error)来当做reward，所以就是：

with tf.variable_scope('exp_v'):
    log_prob = tf.log(self.acts_prob[0, self.a])    # log 动作概率
    self.exp_v = tf.reduce_mean(log_prob * self.td_error)   # log 概率 * TD 方向
with tf.variable_scope('train'):
    # 因为我们想不断增加这个 exp_v (动作带来的额外价值),
    # 所以我们用过 minimize(-exp_v) 的方式达到
    # maximize(exp_v) 的目的
    self.train_op = tf.train.AdamOptimizer(lr).minimize(-self.exp_v)

Critic的更新很简单，就是像Q-Learning那样更新现实和估计的误差(TD_error)就好

with tf.variable_scope('squared_TD_error'):
    self.td_error = self.r + GAMMA * self.v_ - self.v
    self.loss = tf.square(self.td_error)    # TD_error = (r+gamma*V_next) - V_eval
with tf.variable_scope('train'):
    self.train_op = tf.train.AdamOptimizer(lr).minimize(self.loss)

每回合更新：

for i_episode in range(MAX_EPISODE):
    s = env.reset()
    t = 0
    track_r = []    # 每回合的所有奖励
    while True:
        if RENDER: env.render()

        a = actor.choose_action(s)

        s_, r, done, info = env.step(a)

        if done: r = -20    # 回合结束的惩罚

        track_r.append(r)

        td_error = critic.learn(s, r, s_)  # Critic 学习
        actor.learn(s, a, td_error)     # Actor 学习

        s = s_
        t += 1

        if done or t >= MAX_EP_STEPS:
            # 回合结束, 打印回合累积奖励
            ep_rs_sum = sum(track_r)
            if 'running_reward' not in globals():
                running_reward = ep_rs_sum
            else:
                running_reward = running_reward * 0.95 + ep_rs_sum * 0.05
            if running_reward > DISPLAY_REWARD_THRESHOLD: RENDER = True  # rendering
            print("episode:", i_episode, "  reward:", int(running_reward))
            break

完整代码：https://github.com/cristianoc20/RL_learning/tree/master/Actor_Critic_Advantage
参考：莫烦教程 https://github.com/MorvanZhou