Multi-Agent-Verstärkungslernen und Graph-Aufmerksamkeitsnetzwerk: eine End-to-End-Lösung für die Konfliktlösung von UAV-Clustern

Im vorherigen Artikel haben wir das Algorithmus-Panorama der UAV-Konfliktlösung geordnet. Unter ihnen wird Reinforcement Learning (insbesondere MARL) als die „realistischste Option“ für Schwärme von mehr als 50 Drohnen bezeichnet. Dieser Artikel konzentriert sich auf diesen Weg, beginnend mit den Grundlagen des Single-Agent-RL, geht auf die Kernherausforderungen von Multi-Agent-Szenarien ein, analysiert gängige Algorithmen wie MADDPG, QMIX, COMA und MAPPO und konzentriert sich darauf, wie GAT (Graph Attention Network) MARL skalierbare Topologieerkennungsfunktionen bietet und letztendlich eine durchgängige Konfliktlösungsstrategie erreicht.

---

1. Vom Einzelagenten zum Multiagenten: Warum ist MARL so schwierig?

1.1 Single-Agent-RL-Überprüfung

Beginnen wir mit dem bekannten Single-Agent-RL. Das Einzelagenten-MDP wird durch das Vierfache beschrieben:

• Zustandswertfunktion:
• Aktionswertfunktion:
• Optimale Strategie:

Die Kernannahme von Single-Agent RL: Die Umgebung ist stabil – egal wie viele Episoden Sie trainieren, die Dynamik der Umgebung bleibt immer unverändert.

1.2 Drei wesentliche Schwierigkeiten von Multi-Agenten

Multi-Agenten-Szenarien widerlegen diese Annahme und bringen drei grundlegende Schwierigkeiten mit sich:

① Umwelt-Instationarität (Nichtstationarität)

Wenn Agent die Richtlinie lernt, ändern sich auch die Richtlinien anderer Agenten. Das heisst:$$ \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)} \richtig]

Wobei die Aktions-Beobachtungs-Trajektorie des Agenten ist, ist ein monotonisches Mischnetzwerk, das Folgendes erfüllt:

Die Monotoniebeschränkung garantiert eine Schlüsseleigenschaft: Während der dezentralen Ausführung entspricht die unabhängige gierige Maximierung von jedes Agenten der globalen Maximierung von .

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: Der Sieg des politischen Gefälles in hochgradig parallelen Szenarien

MAPPO (Multi-Agent PPO) erweitert den PPO-Algorithmus auf Multi-Agent-Szenarien und hat sich in den letzten Jahren bei UAV-Cluster-Aufgaben gut bewährt (mehrere Top-Konferenzbeiträge von 2022 bis 2024).

Hauptvorteile von PPO: Einschränkungen der Vertrauensregion gewährleisten Trainingsstabilität und vermeiden die Hyperparameter-Katastrophe der DDPG-Serie.

PPO-Clip-Ziel:

Dabei ist das Wahrscheinlichkeitsverhältnis, ist GAE (Generalized Advantage Estimation).Typische Konfiguration von MAPPO bei der UAV-Konfliktlösung:

Parameter	Empfohlene Werte	Beschreibung
Clip-Verhältnis	0,2	PPO-Standard
Horizont	128–256	Anzahl der Rollout-Schritte pro Epoche
PPO-Epochen	2–4	Anzahl wiederholter Aktualisierungen pro Stapel
GAE	0,95	Bias-Varianz-Balance der Dominanzschätzung
Dimension der verborgenen Ebene	64–128	Ausreichend für UAV-Szenarien
Normalisierung	OBS + Belohnungsnormalisierung	Schlüssel! Große Auswirkung auf die Multi-Agenten-Konvergenz

---

3. GAT: Lassen Sie MARL lernen, wem Sie folgen sollen.

3.1 Warum benötigt MARL eine Graphenstruktur?

In einem UAV-Cluster sind nicht alle Agenten gleich wichtig. Nehmen wir als Beispiel Konfliktlösung:

• UAV droht mit mir zu kollidieren → Große Sorge
• UAVs weit außer Sichtweite → können ignoriert werden
• Annäherung an sich bewegende Hindernisse → erfordert dynamische Aufmerksamkeit

Allerdings behandelt traditionelles MARL (wie MADDPG, QMIX) alle Nachbarn gleich: entweder vollständig verbunden (-Kommunikation) oder feste Topologie (wie Ring, nächster Nachbar).

Die Einführung von GAT löst zwei Kernprobleme:

1. Adaptive Nachbargewichtung: Erfahren Sie durch den Aufmerksamkeitsmechanismus, welche Nachbarn für die aktuelle Entscheidung wichtiger sind
2. Skalierbarkeit: Steigt nicht mit der Anzahl der Drohnen und unterstützt dynamische Topologie

3.2 GAT-Grundprinzipien

GAT führt eine Neighbor Aggregation für die Features des Knotens auf jeder Ebene durch, und die Gewichtung wird dynamisch durch den Aufmerksamkeitsmechanismus berechnet:$$ \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)