【QMIX】一种基于Value-Based多智能体算法

QMIX 是一种基于 Value-Based 的多智能体强化学习算法（MARL），其基本思想来源于 Actor-Critic 与 DQN 的结合。使用中心式学习（Centralized Learning）分布式执行（Distributed Execution）的方法，利用中心式 Critic 网络接受全局状态用于指导 Actor 进行更新。QMIX 中 Critic 网络的更新方式和 DQN 相似，使用 TD-Error 进行网络自更新。除此之外，QMIX 中为 Critic 网络设立了 evaluate net 和 target net， 这和 DQN 中的设计思想完全相符。

1. QMIX 解决了什么问题（Motivation）

QMIX 是一种解决多智能体强化学习问题的算法，对于大多数多智能体强化学习问题（MARL）都面临着同样一个问题：信度分配（也叫回报分配）。

这是指，当多个 Agent 在同时执行任务时，我们应该怎样合理的去评价每一个 Agent 的行为效用，举个例子：

假设我们现在正在训练一个算法模型，使用该算法模型去玩 MOBA 类游戏（DOTA 或者 LOL），算法模型需要同时操控 5 个英雄。在训练过程中遇到了这样一个情况：我方 3 个英雄迎面撞上了敌方 1 个英雄。此时，算法模型控制 1 号英雄和 2 号英雄对敌方英雄发起进攻，但却让 3 号英雄撤退。那么最终，因为 2 打 1 的局面，我方成功击败对方英雄，获得了 10 分的奖励分（Reward），那么我们该怎样为我方的这 3 个英雄进行奖励分配？

在上面案例中，我们很明显能看出，在人数占优势的情况下，算法选择让 1 号和 2 号英雄一起发起进攻是一次正确的尝试，而让 3 号英雄尝试撤退显然就不那么明智了。由于对 1 号和 2 号的正确决策，使得整个指挥策略得到了正向的奖励分（Positive Reward），但显然我们不能直接将这个正向奖励分同时应用到这 3 个英雄上。

我们希望被正确决策的英雄（1 号和 2 号）获得较高的奖励分，而被错误决策的英雄（3 号）获得负的惩罚分，即最后的期望得分可能为：1 号（8分），2 号（8分），3 号（-6分）。

三个英雄的得分总和加起来还是 10 分，只是每个英雄能够按照自己的实际情况获得对应的合理奖励分。

这就是 回报分配 的概念。

回报分配通常分为两种类型： 自下而上类型 和 自上而下类型。

• 自上而下类型：这种类型通常指我们只能拿到一个团队的最终得分，而无法获得每一个 Agent 的独立得分，因此我们需要把团队回报（Team Reward）合理的分配给每一个独立的 Agent（Individual Reward），这个过程通常也叫 “独立回报分配”（Individual Reward Assign）。上述例子就属于这种类型，典型的代表算法为 COMA算法。

• 自下而上类型：另外一种类型恰恰相反，指当我们只能获得每个 Agent 的独立回报（Individual）时，如何使得整个团队的团队得分（Team Reward）最大化。

QMIX 算法解决的是上述第二种类型的问题，即，在获得各 Agent 的独立回报的情况下，如何使得整个团队的团队收益最大化问题。

2. QMIX 怎样解决团队收益最大化问题（Method）

2.1 算法大框架 —— 基于 AC 框架的 CTDE（Centralized Training Distributed Execution） 模式

多智能体强化学习（MARL）训练中面临的最大问题是：训练阶段和执行阶段获取的信息可能存在不对等问题。即，在训练的时候我们可以获得大量的全局信息（事实证明，只有获取足够的信息模型才能被有效训练）。

但在最终应用模型的时候，我们是无法获取到训练时那么多的全局信息的，因此，人们提出两个训练网络：一个为中心式训练网络（Critic），该网络只在训练阶段存在，获取全局信息作为输入并指导 Agent 行为控制网络（Actor）进行更新；另一个为行为控制网络（Actor），该网络也是最终被应用的网络，在训练和应用阶段都保持着相同的数据输入。

AC 算法的应用非常广泛，QMIX 在设计时同样借鉴了 AC 的 “中心式网络” 和 “分布式执行器” 的想法，整个网络包含了 Mixing Network（类比 Critic 网络）和 Agent RNN Network（类比 Actor 网络），整个网络架构图如下所示：

下面我们分别来看看 Mixing Network 和 RNN Network 的详细设计。

2.2 Agent RNN Network

QMIX 中每一个 Agent 都由 RNN 网络控制，在训练时你可以为每一个 Agent 个体都训练一个独立的 RNN 网络，同样也可以所有 Agent 复用同一个 RNN 网络，这取决于你自己的设计。

RNN 网络一共包含 3 层，输入层（MLP）→ 中间层（GRU）→ 输出层（MLP），实现代码如下：

class RNN(nn.Module):

    # 所有 Agent 共享同一网络, 因此 input_shape = obs_shape + n_actions + n_agents（one_hot_code）
    def __init__(self, input_shape, args):
        super().__init__()

        self.fc1 = nn.Linear(input_shape, args.rnn_hidden_dim)
        self.rnn = nn.GRUCell(args.rnn_hidden_dim, args.rnn_hidden_dim)     # GRUCell(input_size, hidden_size)
        self.fc2 = nn.Linear(args.rnn_hidden_dim, args.n_actions)

    def forward(self, obs, hidden_state):
        x = F.relu(self.fc1(obs))
        h_in = hidden_state.reshape(-1, self.args.rnn_hidden_dim)
        h = self.rnn(x, h_in)                # GRUCell 的输入要求（current_input, last_hidden_state）
        q = self.fc2(h)                      # h 是这一时刻的隐状态，用于输到下一时刻的RNN网络中去，q 是真实行为Q值输出
        return q, h

2.3 Mixing Network

Mixing 网络相当于 Critic 网络，同时接收 Agent RNN Network 的 Q 值和当前全局状态 $s_t$ ，输出在当前状态下所有 Agent 联合行为 $u$ 的行为效用值 $Q_{tot}$。

Mixing 同样使用神经网络结构，不同的是，上图中蓝色部分（中间层神经元）的权重（weights）和偏差（bias）均由右边红色的神经网络产生。即，Mixing 网络中实际包含两个神经网络，红色参数生成网络 & 蓝色推理网络。

• 参数生成网络： 接收全局状态 $s_t$，生成蓝色网络中的神经元权重（weights）和偏差（bias）。
• 推理网络：接收所有 Agent 的行为效用值 $Q$，并将参数生成网络生成的权重和偏差赋值到网络自身，从而推理出全局效用 $Q_{tot}$。

下图是推理网络示意图，只含有一个隐层，与隐层相连接的 weights 和 bias 均由参数生成网络生成，每一层需要的 weights 和 bias 维度如下图所示：

结合上图，我们来看看 Mixing 网络实现代码：

class QMixNet(nn.Module):
    
    def __init__(self, arglist):
        super().__init__()
        self.arglist = arglist

        # 因为生成的 hyper_w1 需要是一个矩阵，而 pytorch 神经网络只能输出一个向量，
        # 所以就先输出长度为需要的 矩阵行*矩阵列 的向量，然后再转化成矩阵

        # hyper_w1 网络用于输出推理网络中的第一层神经元所需的 weights，
        # 推理网络第一层需要 qmix_hidden * n_agents 个偏差值，因此 hyper_w1 网络输出维度为 qmix_hidden * n_agents
        self.hyper_w1 = nn.Sequential(nn.Linear(arglist.state_shape, arglist.hyper_hidden_dim),
                                      nn.ReLU(),
                                      nn.Linear(arglist.hyper_hidden_dim, arglist.n_agents * arglist.qmix_hidden_dim))
            
        # hyper_w2 生成推理网络需要的从隐层到输出 Q 值的所有 weights，共 qmix_hidden 个
        self.hyper_w2 = nn.Sequential(nn.Linear(arglist.state_shape, arglist.hyper_hidden_dim),
                                      nn.ReLU(),
                                      nn.Linear(arglist.hyper_hidden_dim, arglist.qmix_hidden_dim))

        # hyper_b1 生成第一层网络对应维度的偏差 bias
        self.hyper_b1 = nn.Linear(arglist.state_shape, arglist.qmix_hidden_dim)
        # hyper_b2 生成对应从隐层到输出 Q 值层的 bias
        self.hyper_b2 =nn.Sequential(nn.Linear(arglist.state_shape, arglist.qmix_hidden_dim),
                                     nn.ReLU(),
                                     nn.Linear(arglist.qmix_hidden_dim, 1)
                                     )

    def forward(self, q_values, states):  # states的shape为(episode_num, max_episode_len， state_shape)
        # 传入的q_values是三维的，shape为(episode_num, max_episode_len， n_agents)
        episode_num = q_values.size(0)
        q_values = q_values.view(-1, 1, self.arglist.n_agents)  # (episode_num * max_episode_len, 1, n_agents)
        states = states.reshape(-1, self.arglist.state_shape)  # (episode_num * max_episode_len, state_shape)

        w1 = torch.abs(self.hyper_w1(states))
        b1 = self.hyper_b1(states)

        w1 = w1.view(-1, self.arglist.n_agents, self.arglist.qmix_hidden_dim)
        b1 = b1.view(-1, 1, self.arglist.qmix_hidden_dim)

        hidden = F.elu(torch.bmm(q_values, w1) + b1)	# torch.bmm(a, b) 计算矩阵 a 和矩阵 b 相乘

        w2 = torch.abs(self.hyper_w2(states))
        b2 = self.hyper_b2(states)

        w2 = w2.view(-1, self.arglist.qmix_hidden_dim, 1)
        b2 = b2.view(-1, 1, 1)

        q_total = torch.bmm(hidden, w2) + b2
        q_total = q_total.view(episode_num, -1, 1)
        return q_total

2.4 模型更新流程

至此，我们已经了解了 QMIX 中主要网络的结构了，现在我们来看看训练过程中这些神经网络是如何进行参数更新的吧。

QMIX 的更新方式和 DQN 非常类似，设定 evaluate Net 和 target Net，并利用 TD-Error 完成参数更新：

$$loss=TDError=Q_{tot}(evalutate)-(r+\gamma Q_{tot}(target))$$

由上述公式可以看出，一共存在两个 Mixing 网络（evaluate & target），两个网络分别用于产生 $Q_{tot}(evaluate)$ 和 $Q_{tot}(target)$，两个网络接收不同的输入：

• eval 网络： 接收在状态 $s$ 下每个 Agent RNN Network 所选行为的 $Q$ 值作为输入，输出 $Q_{tot}(evaluate)$。
• target 网络：接收在状态 $s_{next}$ 下每个 Agent RNN Network 所有行为中最大的 $Q$ 值作为输入，输出 $Q_{tot}(target)$。

实现代码如下：

    def learn(self, batch):
    
        episode_num = batch['o'].shape[0]
        self.init_hidden(episode_num)

        # 把 batch 里的数据转化成 tensor
        for key in batch.keys():
            if key == 'u':
                batch[key] = torch.tensor(batch[key], dtype=torch.long)
            else:
                batch[key] = torch.tensor(batch[key], dtype=torch.float32)

        s, s_next, u, r, avail_u, avail_u_next, terminated = batch['s'], batch['s_next'], batch['u'], \
                                                             batch['r'],  batch['avail_u'], batch['avail_u_next'],\
                                                             batch['terminated']

        # 得到每个 agent 对应的 Q 值列表
        q_evals, q_targets = self.get_q_values(batch)

        # 取出每个 agent 所选择动作的对应 Q 值
        q_evals = torch.gather(q_evals, dim=3, index=u).squeeze(3)

        # 得到target_q，取所有行为中最大的 Q 值
        q_targets[avail_u_next == 0.0] = - 9999999      # 如果该行为不可选，则把该行为的Q值设为极小值，保证不会被选到
        q_targets = q_targets.max(dim=3)[0]

        # qmix更新过程，evaluate网络输入的是每个agent选出来的行为的q值，target网络输入的是每个agent最大的q值，和DQN更新方式一样
        q_total_eval = self.eval_qmix_net(q_evals, s)
        q_total_target = self.target_qmix_net(q_targets, s_next)

        targets = r + self.arglist.gamma * q_total_target * (1 - terminated)

        td_error = (q_total_eval - targets.detach())

        # 不能直接用mean，因为还有许多经验是没用的，所以要求和再比真实的经验数，才是真正的均值
        loss = (masked_td_error ** 2).sum() / mask.sum()
        self.optimizer.zero_grad()
        loss.backward()
        torch.nn.utils.clip_grad_norm_(self.eval_parameters, self.arglist.grad_norm_clip)
        self.optimizer.step()

		# 在指定周期更新 target network 的参数
        if train_step > 0 and train_step % self.arglist.target_update_cycle == 0:
            self.target_rnn.load_state_dict(self.eval_rnn.state_dict())
            self.target_qmix_net.load_state_dict(self.eval_qmix_net.state_dict())

3. QMIX 效果

下图是 QMIX 论文中给出的 QMIX 与其他算法之间的效果对比图：

可以看出，QMIX 相较于 IQL 有明显大幅度的提升，并且比 VDN 具有更优的效果。QMIX 实质上是 VDN 的一个改进版本，在 VDN 中直接将每个 Agent 的 $Q$ 值相加得到 $Q_{tot}$，而在 QMIX 中，利用两个神经网络，结合每个 Agent 的 $Q$ 值与全局状态 $s_t$ 共同推理出全局效用 $Q_{tot}$，从结果来看确实比 VDN 在效果上有一定的提升。

QMIX 论文链接： https://arxiv.org/pdf/1803.11485.pdf
QMIX 实现代码：https://github.com/oxwhirl/smac