多智能体强化学习之MADDPG

论文原文：Multi-Agent Actor-Critic for Mixed Cooperative-Competitive Environments

论文翻译：MADDPG翻译

阅读本文需要强化学习基础，可以参考我前面的文章：多智能体强化学习入门

关于MADDPG强化学习算法的基础DDPG的可以查看我的文章：强化学习实践教学

对于MADDPG推荐的博客有：探秘多智能体强化学习-MADDPG算法原理及简单实现，里面包含代码实现。

github代码（基于Tensorflow）：https://github.com/princewen/tensorflow_practice/tree/master/RL/Basic-MADDPG-Demo

MADDPG算法是单智能体算法DDPG在多智能体环境下的改进。其中最核心的差别就是，每个Agent的Critic部分都能够获取所有Agent的动作信息，进行中心化训练和非中心化执行。即在训练的时候，引入可以观察全局的critic来指导actor训练，而测试的时候只使用有局部观测的actor采取行动。off-line采用中心化训练，on-line采用非中心化执行，on-line与off-line的共同点就是actor，即只需要利用观测到的局部信息。

下面以两个智能体的情况为例：
$$r_1(s,a_1)=E_{a_2\in A,s^{\prime }\in S}[r_1(s^{\prime })p(s^{\prime }|s,a_1,a_2){\pi }_2(a_2|s)]$$

$$p_1(s^{\prime }|s,a_1)=\sum _{a_2\in A}p(s^{\prime }|s,a_1,a_2){\pi }_2(a_2|s)$$

根据论文描述，算法在以下约束条件下运行：（1）学习的策略只能在执行时只能使用本地信息（即它们自己的观察结果），（2）我们无需知道环境的可微分动力学模型（3）我们对智能体之间的通信方法不做任何结构上的假设（即，我们不假设一个可区分的通信渠道）。 一旦满足上述要求，那么将产生一个通用的多智能体学习算法，不仅可以应用于具有明确通信渠道的合作博弈，还可以应用竞争性博弈和只涉及主体之间物理交互的博弈。

论文中三个改进是：

1. 集中式训练，分布式执行：训练时采用集中式学习训练critic与actor，使用时actor只用知道局部信息就能运行。critic需要其他智能体的策略信息，本文给了一种估计其他智能体策略的方法，能够只用知道其他智能体的观测与动作。
2. 改进了经验回放记录的数据。为了能够适用于动态环境，每一条信息由$(x,x^{\prime },a_q,...,a_n,r_1,...,r_n)$ 组成，$x=(o_1,...,o_n)$ 表示每个智能体的观测。
3. 利用策略集合效果优化（policy ensemble）：对每个智能体学习多个策略，改进时利用所有策略的整体效果进行优化。以提高算法的稳定性以及鲁棒性。

代码

def actor_network(name):
    with tf.variable_scope(name) as scope:
        x = state_input
        x = tf.layers.dense(x, 64)
        if self.layer_norm:
            x = tc.layers.layer_norm(x, center=True, scale=True)
        x = tf.nn.relu(x)

        x = tf.layers.dense(x, 64)
        if self.layer_norm:
            x = tc.layers.layer_norm(x, center=True, scale=True)
        x = tf.nn.relu(x)

        x = tf.layers.dense(x, self.nb_actions,
        kernel_initializer=tf.random_uniform_initializer(minval=-3e-3, maxval=3e-3))
        x = tf.nn.tanh(x)
    return x


def critic_network(name, action_input, reuse=False):
    with tf.variable_scope(name) as scope:
        if reuse:
            scope.reuse_variables()

        x = state_input
        x = tf.layers.dense(x, 64)
        if self.layer_norm:
            x = tc.layers.layer_norm(x, center=True, scale=True)
        x = tf.nn.relu(x)

        x = tf.concat([x, action_input], axis=-1)
        x = tf.layers.dense(x, 64)
        if self.layer_norm:
            x = tc.layers.layer_norm(x, center=True, scale=True)
        x = tf.nn.relu(x)

        x = tf.layers.dense(x, 1, kernel_initializer=tf.random_uniform_initializer(minval=-3e-3, maxval=3e-3))
    return x

上面是模型部分的代码，actor部分相对于DDPG没有变化，Critic部分只需要加入其它智能体的动作作为输入即可。

 # 最大化Q值
self.actor_loss = -tf.reduce_mean(
critic_network(name + '_critic', action_input=tf.concat([self.action_output, other_action_input], axis=1),
reuse=True))
self.actor_train = self.actor_optimizer.minimize(self.actor_loss)

self.target_Q = tf.placeholder(shape=[None, 1], dtype=tf.float32)
self.critic_loss = tf.reduce_mean(tf.square(self.target_Q - self.critic_output))
self.critic_train = self.critic_optimizer.minimize(self.critic_loss)

在Loss计算上可以看到依旧遵循DDPG的方法。Critic的估计值尽量靠近预测值，actor尽量使得Critic的估计值越大越好。

agent1_memory.add(np.vstack([o_n[0], o_n[1], o_n[2]]),
                  np.vstack([agent1_action[0], agent2_action[0], agent3_action[0]]),
                  r_n[0], np.vstack([o_n_next[0], o_n_next[1], o_n_next[2]]), False)

agent2_memory.add(np.vstack([o_n[1], o_n[2], o_n[0]]),
                  np.vstack([agent2_action[0], agent3_action[0], agent1_action[0]]),
                  r_n[1], np.vstack([o_n_next[1], o_n_next[2], o_n_next[0]]), False)

agent3_memory.add(np.vstack([o_n[2], o_n[0], o_n[1]]),
                  np.vstack([agent3_action[0], agent1_action[0], agent2_action[0]]),
                  r_n[2], np.vstack([o_n_next[2], o_n_next[0], o_n_next[1]]), False)

在经验池储存上，MADDPG不但要储存自身的可观察的状态信息，还要储存的是其它智能体的可观测状态信息。同时储存自身和他人的动作信息。以及每个智能体的下一个状态。