Apprentissage par renforcement multi-agents et réseau d’attention aux graphes : une solution de bout en bout pour la résolution des conflits de clusters de drones

Dans article précédent, nous avons fait le tour du panorama algorithmique de la résolution des conflits avec les drones. Parmi eux, l’apprentissage par renforcement (en particulier MARL) est considéré comme « l’option la plus réaliste » pour des essaims de plus de 50 drones. Cet article se concentrera sur cette voie, en commençant par la fondation du RL mono-agent, en passant par les principaux défis des scénarios multi-agents, en analysant les algorithmes traditionnels tels que MADDPG, QMIX, COMA et MAPPO, et en se concentrant sur la façon dont GAT (Graph Attention Network) fournit à MARL des capacités de connaissance de la topologie évolutives et parvient finalement à une stratégie de résolution des conflits de bout en bout.

---

1. Du mono-agent au multi-agent : Pourquoi MARL est-il si difficile ?

1.1 Examen du RL à agent unique

Commençons par le RL familier à agent unique. Le MDP mono-agent est décrit par le quadruple  :

• Fonction de valeur d’état :
• Fonction de valeur d’action :
• Stratégie optimale :

L’hypothèse de base du RL à agent unique : L’environnement est stable - quel que soit le nombre d’épisodes que vous entraînez, la dynamique de l’environnement reste toujours inchangée.

1.2 Trois difficultés essentielles du multi-agent

Les scénarios multi-agents brisent cette hypothèse et entraînent trois difficultés fondamentales :

① Non-stationnarité environnementale (Non-Stationnarité)

Lorsque l’agent apprend la politique , les politiques des autres agents changent également. Cela signifie:$$ \mathcal{P}_i(s’\mid s, a_1,\dots,a_n) \neq \mathcal{P}_i(s’\mid s, a_1,\dots,a_n, a_1’,\dots,a_n’)

r_t = f(\mathbf{s}_t, \mathbf{a}t, \mathbf{s}{t+1})

\nabla_{\theta_i} J(\theta_i) = \mathbb{E}{\mathbf{s} \sim \mathcal{D}}\left[ \nabla{\theta_i} \log \pi_i(a_i \mid o_i) \cdot Q_i^\pi(\mathbf{s}, a_1, \dots, a_n) \Big|_{a_i = \pi_i(o_i)} \droite]

Où est la trajectoire action-observation de l’agent , est un réseau de mélange monotone, satisfaisant :

La contrainte de monotonie garantit une propriété clé : Lors d’une exécution décentralisée, la maximisation gloutonne indépendante de de chaque agent est équivalente à la maximisation globale de .

class QMIXMixingNetwork(nn.Module):
    """
    单调混合网络：将各智能体的 Q_i 混合为全局 Q_tot
    关键约束：所有权值非负（保证单调性）
    """
    def __init__(self, n_agents, embed_dim=64):
        super().__init__()
        # Hyper-network 生成混合网络的权值
        self.hyper_w1 = nn.Sequential(
            nn.Linear(n_agents, embed_dim),
            nn.ReLU(),
            nn.Linear(embed_dim, n_agents * embed_dim),  # 输出 (n_agents × embed_dim) 权值
        )
        self.hyper_b1 = nn.Linear(n_agents, embed_dim)
        self.hyper_w2 = nn.Sequential(
            nn.Linear(embed_dim, embed_dim),
            nn.ReLU(),
            nn.Linear(embed_dim, embed_dim)
        )
        self.hyper_b2 = nn.Linear(embed_dim, 1)
    
    def forward(self, q_values, state):
        """
        q_values: (batch, n_agents) 各智能体的 Q 值
        state: (batch, state_dim) 全局状态（用于生成 hyper-network 输入）
        """
        batch_size = q_values.size(0)
        
        # 第一层：W₁ * Q + b₁
        w1 = torch.abs(self.hyper_w1(state))          # (batch, n_agents * embed_dim)
        w1 = w1.view(batch_size, q_values.size(1), -1)  # (batch, n_agents, embed_dim)
        b1 = self.hyper_b1(state).unsqueeze(1)       # (batch, 1, embed_dim)
        
        q_hidden = torch.relu(torch.bmm(q_values.unsqueeze(1), w1) + b1)  # (batch, 1, embed_dim)
        
        # 第二层：W₂ * h + b₂
        w2 = torch.abs(self.hyper_w2(q_hidden.squeeze(1)))  # (batch, embed_dim, embed_dim)
        b2 = self.hyper_b2(q_hidden.squeeze(1)).unsqueeze(1)  # (batch, 1, 1)
        
        q_tot = torch.bmm(q_hidden, w2.unsqueeze(1)) + b2  # (batch, 1, 1)
        return q_tot.squeeze(-1)  # (batch,)


class QMIXAgent:
    """QMIX 算法"""
    def __init__(self, obs_dim, action_dim, n_agents, agent_id):
        self.agent_id = agent_id
        self.action_dim = action_dim
        
        # 每个智能体的 RNN（处理动作-观测历史）
        self.rnn = nn.GRUCell(obs_dim + action_dim, obs_dim)
        # Q 网络
        self.q_net = nn.Sequential(
            nn.Linear(obs_dim, 64),
            nn.ReLU(),
            nn.Linear(64, 64),
            nn.ReLU(),
            nn.Linear(64, action_dim)
        )
        
        self.target_rnn = nn.GRUCell(obs_dim + action_dim, obs_dim)
        self.target_q_net = nn.Sequential(
            nn.Linear(obs_dim, 64),
            nn.ReLU(),
            nn.Linear(64, 64),
            nn.ReLU(),
            nn.Linear(64, action_dim)
        )
        self.hard_update()
    
    def hard_update(self):
        self.target_rnn.load_state_dict(self.rnn.state_dict())
        self.target_q_net.load_state_dict(self.q_net.state_dict())
    
    def get_q_values(self, hidden, obs, last_action):
        """给定 (hidden, obs, last_action) 输出 Q(s,a)"""
        rnn_input = torch.cat([obs, last_action], dim=1)
        new_hidden = self.rnn(rnn_input, hidden)
        q_values = self.q_net(new_hidden)
        return q_values, new_hidden
    
    def select_action_epsilon_greedy(self, q_values, epsilon):
        """ε-贪心策略"""
        if random.random() < epsilon:
            return random.randint(0, self.action_dim - 1)
        return q_values.argmax(dim=1).item()


def train_qmix():
    """QMIX 训练循环（伪代码）"""
    n_agents = 8
    n_episodes = 50000
    
    agents = [QMIXAgent(obs_dim=12, action_dim=5, n_agents=n_agents, agent_id=i)
              for i in range(n_agents)]
    mixer = QMIXMixingNetwork(n_agents)
    
    optimizers = [optim.Adam(agent.q_net.parameters(), lr=2e-4) for agent in agents]
    mixer_optimizer = optim.Adam(mixer.parameters(), lr=2e-4)
    
    replay = ReplayBuffer(capacity=100000)
    
    for ep in range(n_episodes):
        # 环境交互
        states = env.reset()  # (n_agents, obs_dim)
        hidden = [torch.zeros(1, 12) for _ in range(n_agents)]
        last_actions = [torch.zeros(1, 5) for _ in range(n_agents)]
        episode_reward = 0
        
        while not done:
            actions = []
            for i, agent in enumerate(agents):
                q_vals, hidden[i] = agent.get_q_values(hidden[i],
                    torch.FloatTensor(states[i]).unsqueeze(0),
                    last_actions[i])
                a = agent.select_action_epsilon_greedy(q_vals.squeeze(0), epsilon=0.1)
                actions.append(a)
                last_actions[i] = torch.zeros(1, 5)
                last_actions[i][0, a] = 1.0
            
            next_states, rewards, done = env.step(actions)
            replay.push(states, last_actions, rewards, next_states, done)
            states = next_states
            episode_reward += sum(rewards)
        
        # 学习
        if len(replay) > 1024:
            batch = replay.sample(32)
            # QMIX 损失计算 ...
            # 单调混合 + 中心化训练 ...

2.4 MAPPO : La victoire du gradient politique dans des scénarios hautement parallèles

MAPPO (Multi-Agent PPO) étend l’algorithme PPO aux scénarios multi-agents et a obtenu de bons résultats dans les tâches de cluster de drones ces dernières années (plusieurs articles de conférence de premier plan de 2022 à 2024).

Principaux avantages du PPO : les contraintes de région de confiance garantissent la stabilité de la formation et évitent le désastre des hyperparamètres de la série DDPG.

Cible du clip PPO :

Où est le rapport de probabilité, est GAE (Generalized Advantage Estimation).Configuration typique de MAPPO dans la résolution de conflits de drones :

Paramètres	Valeurs recommandées	Descriptif
Rapport de découpage	0,2	PPO par défaut
Horizon	128-256	Nombre d’étapes de déploiement par époque
Époques PPO	2–4	Nombre de mises à jour répétées par lot
GAE	0,95	Bilan-variance de l’estimation de la dominance
Dimension de couche cachée	64-128	Suffisant pour les scénarios de drones
Normalisation	OBS + Normalisation des récompenses	Clé! Grand impact sur la convergence multi-agents

---

3. GAT : Laissez MARL apprendre “qui suivre”

3.1 Pourquoi MARL a-t-il besoin d’une structure graphique ?

Dans un cluster de drones, tous les agents n’ont pas la même importance. Prenons l’exemple de la résolution de conflits :

• Un drone sur le point d’entrer en collision avec moi → Forte préoccupation
• Les drones hors de vue → peuvent être ignorés
• Approcher des obstacles en mouvement → nécessite une attention dynamique

Cependant, le MARL traditionnel (tel que MADDPG, QMIX) traite tous les voisins de la même manière : soit entièrement connectés ( communication), soit à topologie fixe (telle que l’anneau, le voisin le plus proche).

L’introduction de GAT résout deux problèmes fondamentaux :

1. Poids adaptatif du voisin : découvrez quels voisins sont les plus importants pour la décision actuelle grâce au mécanisme d’attention
2. Évolutivité : n’augmente pas avec le nombre de drones et prend en charge la topologie dynamique

3.2 Principes fondamentaux du GAT

GAT effectue une Agrégation de voisins sur les caractéristiques du nœud à chaque couche, et le poids est calculé dynamiquement par le mécanisme d’attention :$$ \alpha_{ij} = \frac{\exp\left(\text{LeakyReLU}\left(\mathbf{a}^\top[\mathbf{W}\mathbf{h}_i \Vert \mathbf{W}\mathbf{h}j]\right)\right)} {\sum{k \in \mathcal{N}_i} \exp\left(\text{LeakyReLU}\left(\mathbf{a}^\top[\mathbf{W}\mathbf{h}_i \Vert \mathbf{W}\mathbf{h}_k]\right)\right)}

\mathbf{h}i’ = \sigma\left(\sum{j \in \mathcal{N}i} \alpha{ij} \mathbf{W}\mathbf{h}_j\right)

\pi_{safe}(s) = \text{Proj}{\mathcal{A}{safe}(s)} \pi(s)