本文首发于：行者AI
Qmix是多智能体强化学习中比较经典的算法之一，在VDN的基础上做了一些改进，与VDN相比，在各个agent之间有着较大差异的环境中，表现的更好。
1. IQL与VDN
IQL（Independent Q_Learning），是一种比较暴力的解决问题的方法，每个agent都各自为政，自己学习自己的，没有一个共同的目标。导致算法最终很难收敛。但是在实际一些问题中有不错的表现。
VDN（Value-Decomposition Networks For CooperativeMulti-Agent Learning），每个agent都有自己的动作价值函数(Q_a)，通过各自的价值函数的(argmaxQ_a)，选取动作。(Q_{tot}=sum_{i=1}^nQ_i)，主要将系统的联合(Q_{tot})近似成为多个单智能体的(Q_a)函数的和。因为VDN的联合函数的求和形式表现力有限，在有复杂组合的环境中，表现的很差。例如非线性环境。
2. Qmix
2.1 Qmix的算法思想
QMIX的主要目的：找到一个完全去中心化的策略，并没有像VDN一样完全分解，为了保持策略一致性，我们只需要是全局的(Q_{tot})的执行与(argmaxQa)上的执行的结果相同：
要达到这个效果只需要满足(Q_{tot})对于任何一个(Q_a)都是单调递增的：
不难看出，当(frac {partial Q_{tot}}{partial Q_a}=1)的时候就是VDN，VDN是QMIX的一种特殊情况。
2.2 Qmix的网络结构
QMIX的模型由两大部分组成（三个网络组成），一个是agent network，输出单智能体的(Q_i)的函数，mixing network则是以(Q_i)作为输入，输出为联合(Q_{tot})。为了保证单调性，mixing network的网络参数权重和偏置通过hypernetworks网络计算得出，并且hypernetworks输出的网络权重都必须大于0，对偏置没有要求。
3. 算法流程
-
初始化网络eval_agent_network，eval_mixing_network这两个网络，分别将这两个网络的参数复制给target_agent_network，targent_mixing_network.初始化buffer (D),容量为(M)，总迭代轮数(T)，target_agent_network，targent_mixing_network两个网络参数更新频率(p)。
-
(for) (t=1) $to $ (T) $ do$
1）初始化环境
2）获取环境的(S)，每个agent的观察值(O)，每个agent的(avail) (action)，奖励(R)。
3）(for) (step=1) (to) (episode)_(limit)
a）每个agent通过eval_agent_network获取每个动作的(Q)值，eval_agent_network中有GRU循环层，需要记录每个agnet的隐藏层，作为下次GRU隐藏的输入。（一一对应）
b）通过计算出的Q值选择动作。（1，通过最大的(Q)值进行选取动作，有小几率采取随机动作。2，将(Q)值再进行一次softmax，随机采样（sample）动作）
c）将(S)，(S_{next})，每个agent的观察值(O)，每个agent的(avail) (action)，每个agent的(next) (avail) (action)，奖励(R)，选择的动作(u)，env是否结束(terminated)，存入经验池(D)。
d）(if) (len(D)) (>=) (M)
e）随机从(D)中采样一些数据，但是数据必须是不同的episode中的相同transition。因为在选动作时不仅需要输入当前的inputs，还要给神经网络输入hidden_state，hidden_state和之前的经验相关，因此就不能随机抽取经验进行学习。所以这里一次抽取多个episode，然后一次给神经网络传入每个episode的同一个位置的transition。
f）通过DQN相同的方式更新参数：
(L( heta)=sum_{i=1}^b[(y_i^{tot}-Q_{tot}( au,u,s; heta))^2])
g）(if) (terminated) == (True) (and) (step) (<=) (episode)_(limit)
h）(for) (k=step) (to) (episode)_(limit)
i）将不足的数据用0进行填充，保证数据的一致性。
j）(S,availspacespace action = S_{next},next space avail space action)
k）(if) (t) % (p==0)
l）将eval_agent_network，eval_mixing_network网络参数复制给target_agent_network，targent_mixing_network
4. 结果分析
关于QMIX的实验结果，paper中先用一个比较简单的tabular的游戏two-step game来证明了QMIX相较于VDN，更容易找到最优解，而VDN则会陷入局部最优解（具体内容有兴趣的读者可以查阅论文第5节）。 作者在星际争霸2的多个任务下也进行了实验测试，如下图所示：
在paper中还提到了QMIX要比VDN更好的使联合动作的优势更加突出，下图中，a表示VDN，b表示QMIX，agent1和agent2在学习之后，VDN中A和B的联合最优动作的价值为6.51，而QMIX的联合最优动作的价值为8.0。可以看出QMIX体现出的优势联合动作的价值更大。
5. 关键代码
5.1 网络结构
agent_network，采用循环神经网络GRU，上一回合输出的隐藏做为当前回合的输入。
class RNN(nn.Module):
# Because all the agents share the same network, input_shape=obs_shape+n_actions+n_agents
def __init__(self, input_shape, args):
super(RNN, self).__init__()
self.args = args
self.fc1 = nn.Linear(input_shape, args.rnn_hidden_dim)
self.rnn = nn.GRUCell(args.rnn_hidden_dim, args.rnn_hidden_dim)
self.fc2 = nn.Linear(args.rnn_hidden_dim, args.n_actions)
def forward(self, obs, hidden_state):
x = f.relu(self.fc1(obs))
# print(hidden_state.shape,"xxxxx")
h_in = hidden_state.reshape(-1, self.args.rnn_hidden_dim)
# print(h_in.shape,"uuu")
h = self.rnn(x, h_in)
q = self.fc2(h)
print(q)
print(h)
return q, h
class QMixNet(nn.Module):
def __init__(self, args):
super(QMixNet, self).__init__()
self.args = args
# 因为生成的hyper_w1需要是一个矩阵，而pytorch神经网络只能输出一个向量，
# 所以就先输出长度为需要的 矩阵行*矩阵列 的向量，然后再转化成矩阵
# args.n_agents是使用hyper_w1作为参数的网络的输入维度，args.qmix_hidden_dim是网络隐藏层参数个数
# 从而经过hyper_w1得到(经验条数，args.n_agents * args.qmix_hidden_dim)的矩阵
if args.two_hyper_layers:
self.hyper_w1 = nn.Sequential(nn.Linear(args.state_shape, args.hyper_hidden_dim),
nn.ReLU(),
nn.Linear(args.hyper_hidden_dim, args.n_agents * args.qmix_hidden_dim))
# 经过hyper_w2得到(经验条数, 1)的矩阵
self.hyper_w2 = nn.Sequential(nn.Linear(args.state_shape, args.hyper_hidden_dim),
nn.ReLU(),
nn.Linear(args.hyper_hidden_dim, args.qmix_hidden_dim))
else:
self.hyper_w1 = nn.Linear(args.state_shape, args.n_agents * args.qmix_hidden_dim)
# 经过hyper_w2得到(经验条数, 1)的矩阵
self.hyper_w2 = nn.Linear(args.state_shape, args.qmix_hidden_dim * 1)
# hyper_w1得到的(经验条数，args.qmix_hidden_dim)矩阵需要同样维度的hyper_b1
self.hyper_b1 = nn.Linear(args.state_shape, args.qmix_hidden_dim)
# hyper_w2得到的(经验条数，1)的矩阵需要同样维度的hyper_b1
self.hyper_b2 =nn.Sequential(nn.Linear(args.state_shape, args.qmix_hidden_dim),
nn.ReLU(),
nn.Linear(args.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.args.n_agents) # (episode_num * max_episode_len, 1, n_agents) = (1920,1,5)
states = states.reshape(-1, self.args.state_shape) # (episode_num * max_episode_len, state_shape)
w1 = torch.abs(self.hyper_w1(states)) # (1920, 160)
b1 = self.hyper_b1(states) # (1920, 32)
w1 = w1.view(-1, self.args.n_agents, self.args.qmix_hidden_dim) # (1920, 5, 32)
b1 = b1.view(-1, 1, self.args.qmix_hidden_dim) # (1920, 1, 32)
hidden = F.elu(torch.bmm(q_values, w1) + b1) # (1920, 1, 32)
w2 = torch.abs(self.hyper_w2(states)) # (1920, 32)
b2 = self.hyper_b2(states) # (1920, 1)
w2 = w2.view(-1, self.args.qmix_hidden_dim, 1) # (1920, 32, 1)
b2 = b2.view(-1, 1, 1) # (1920, 1， 1)
q_total = torch.bmm(hidden, w2) + b2 # (1920, 1, 1)
q_total = q_total.view(episode_num, -1, 1) # (32, 60, 1)
return q_total
5.2 动作选择
这里采用的是epsilon的方式更新，有一定的几率随机选取动作。另一种方式，将Q值再进行一次softmax，然后采样获取动作。
def choose_action(self, obs, last_action, agent_num, avail_actions, epsilon, maven_z=None, evaluate=False):
inputs = obs.copy()
avail_actions_ind = np.nonzero(avail_actions)[0] # index of actions which can be choose
# transform agent_num to onehot vector
agent_id = np.zeros(self.n_agents)
agent_id[agent_num] = 1.
if self.args.last_action:
inputs = np.hstack((inputs, last_action))
if self.args.reuse_network:
inputs = np.hstack((inputs, agent_id))
# print("input:", inputs, last_action, agent_id)
# print("hidden:", self.policy.eval_hidden.shape)
hidden_state = self.policy.eval_hidden[:, agent_num, :]
# transform the shape of inputs from (42,) to (1,42)
inputs = torch.tensor(inputs, dtype=torch.float32).unsqueeze(0)
avail_actions = torch.tensor(avail_actions, dtype=torch.float32).unsqueeze(0)
if self.args.cuda:
inputs = inputs.cuda()
hidden_state = hidden_state.cuda()
# get q value
q_value, self.policy.eval_hidden[:, agent_num, :] = self.policy.eval_rnn(inputs, hidden_state)
# choose action from q value
q_value[avail_actions == 0.0] = - float("inf")
if np.random.uniform() < epsilon:
action = np.random.choice(avail_actions_ind) # action是一个整数
else:
action = torch.argmax(q_value)
return action
5.3 learn更新网络参数
在learn的时候，抽取到的数据是四维的，四个维度分别为 1——第几个episode 2——episode中第几个transition 3——第几个agent的数据 4——具体obs维度。因为在选动作时不仅需要输入当前的inputs，还要给神经网络输入hidden_state，hidden_state和之前的经验相关，因此就不能随机抽取经验进行学习。所以这里一次抽取多个episode，然后一次给神经网络传入每个episode的同一个位置的transition。
def learn(self, batch, max_episode_len, train_step, epsilon=None): # train_step表示是第几次学习，用来控制更新target_net网络的参数
episode_num = batch['o'].shape[0]
self.init_hidden(episode_num)
for key in batch.keys(): # 把batch里的数据转化成tensor
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']
mask = 1 - batch["padded"].float() # 用来把那些填充的经验的TD-error置0，从而不让它们影响到学习
# 得到每个agent对应的Q值，维度为(episode个数，max_episode_len， n_agents，n_actions)
q_evals, q_targets = self.get_q_values(batch, max_episode_len)
if self.args.cuda:
s = s.cuda()
u = u.cuda()
r = r.cuda()
s_next = s_next.cuda()
terminated = terminated.cuda()
mask = mask.cuda()
# 取每个agent动作对应的Q值，并且把最后不需要的一维去掉，因为最后一维只有一个值了
q_evals = torch.gather(q_evals, dim=3, index=u).squeeze(3)
# 得到target_q
q_targets[avail_u_next == 0.0] = - 9999999
q_targets = q_targets.max(dim=3)[0]
q_total_eval = self.eval_qmix_net(q_evals, s)
q_total_target = self.target_qmix_net(q_targets, s_next)
targets = r + self.args.gamma * q_total_target * (1 - terminated)
td_error = (q_total_eval - targets.detach())
masked_td_error = mask * td_error # 抹掉填充的经验的td_error
# 不能直接用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.args.grad_norm_clip)
self.optimizer.step()
if train_step > 0 and train_step % self.args.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())
def _get_inputs(self, batch, transition_idx):
# 取出所有episode上该transition_idx的经验，u_onehot要取出所有，因为要用到上一条
obs, obs_next, u_onehot = batch['o'][:, transition_idx],
batch['o_next'][:, transition_idx], batch['u_onehot'][:]
episode_num = obs.shape[0]
inputs, inputs_next = [], []
inputs.append(obs)
inputs_next.append(obs_next)
# 给obs添加上一个动作、agent编号
if self.args.last_action:
if transition_idx == 0: # 如果是第一条经验，就让前一个动作为0向量
inputs.append(torch.zeros_like(u_onehot[:, transition_idx]))
else:
inputs.append(u_onehot[:, transition_idx - 1])
inputs_next.append(u_onehot[:, transition_idx])
if self.args.reuse_network:
# 因为当前的obs三维的数据，每一维分别代表(episode编号，agent编号，obs维度)，直接在dim_1上添加对应的向量
# 即可，比如给agent_0后面加(1, 0, 0, 0, 0)，表示5个agent中的0号。而agent_0的数据正好在第0行，那么需要加的
# agent编号恰好就是一个单位矩阵，即对角线为1，其余为0
inputs.append(torch.eye(self.args.n_agents).unsqueeze(0).expand(episode_num, -1, -1))
inputs_next.append(torch.eye(self.args.n_agents).unsqueeze(0).expand(episode_num, -1, -1))
# 要把obs中的三个拼起来，并且要把episode_num个episode、self.args.n_agents个agent的数据拼成40条(40,96)的数据，
# 因为这里所有agent共享一个神经网络，每条数据中带上了自己的编号，所以还是自己的数据
inputs = torch.cat([x.reshape(episode_num * self.args.n_agents, -1) for x in inputs], dim=1)
inputs_next = torch.cat([x.reshape(episode_num * self.args.n_agents, -1) for x in inputs_next], dim=1)
return inputs, inputs_next
def get_q_values(self, batch, max_episode_len):
episode_num = batch['o'].shape[0]
q_evals, q_targets = [], []
for transition_idx in range(max_episode_len):
inputs, inputs_next = self._get_inputs(batch, transition_idx) # 给obs加last_action、agent_id
if self.args.cuda:
inputs = inputs.cuda()
inputs_next = inputs_next.cuda()
self.eval_hidden = self.eval_hidden.cuda()
self.target_hidden = self.target_hidden.cuda()
q_eval, self.eval_hidden = self.eval_rnn(inputs, self.eval_hidden) # inputs维度为(40,96)，得到的q_eval维度为(40,n_actions)
q_target, self.target_hidden = self.target_rnn(inputs_next, self.target_hidden)
# 把q_eval维度重新变回(8, 5,n_actions)
q_eval = q_eval.view(episode_num, self.n_agents, -1)
q_target = q_target.view(episode_num, self.n_agents, -1)
q_evals.append(q_eval)
q_targets.append(q_target)
# 得的q_eval和q_target是一个列表，列表里装着max_episode_len个数组，数组的维度是(episode个数, n_agents，n_actions)
# 把该列表转化成(episode个数，max_episode_len，n_agents，n_actions)的数组
q_evals = torch.stack(q_evals, dim=1)
q_targets = torch.stack(q_targets, dim=1)
return q_evals, q_targets
5.4 代码总结
MARL的代码相对来说要比single RL的代码要复杂的多，笔者还是建议读者看懂原理之后，自己手敲一遍，敲一遍之后会对一个算法的理解程度大大的提升。
6. 资料
QMIX: Monotonic Value Function Factorisation for Deep Multi-Agent Reinforcement Learning
PS：更多技术干货，快关注【公众号 | xingzhe_ai】，与行者一起讨论吧！