专注仿真头像
基于 AFSIM 的智能体训练:多智能体强化学习篇 —— VDN 算法实战封面图

基于 AFSIM 的智能体训练:多智能体强化学习篇 —— VDN 算法实战

1. 引言:为什么要在 AFSIM 里做多智能体强化学习

AFSIM(Advanced Framework for Simulation, Integration, and Modeling)是美军广泛使用的作战仿真框架,能够对传感器、通信、武器、平台机动等要素进行高保真建模。传统上,AFSIM 中的智能体行为依赖脚本(WSF Script)或有限状态机来编写,规则由人手工设计,面对复杂对抗场景时难以覆盖所有情况。

多智能体强化学习(MARL)提供了一条新路径:让多个智能体在仿真环境中通过试错学习协同策略。但 MARL 落地到 AFSIM 面临三个现实问题:

  • 环境接口:AFSIM 是 C++ 仿真内核,需要把仿真状态导出为强化学习可用的观测,并把动作回写为平台指令。
  • 信用分配:多个智能体共享一个团队奖励,如何判断"谁的贡献大"是核心难点。
  • 训练效率:作战仿真单步耗时长,必须用尽量少的样本学到有效策略。

本文聚焦第二个问题,用 VDN(Value Decomposition Networks) 算法完成一次完整的实战:在 AFSIM 场景中训练一组协同作战的智能体。VDN 结构简单、易于实现,是理解值分解类 MARL 算法的最佳起点。

2. VDN 算法核心思想

2.1 从 IQL 到 VDN

最朴素的多智能体方法是独立 Q 学习(IQL):每个智能体各自维护一个 Q 网络,把其他智能体当作环境的一部分。问题在于环境非平稳——其他智能体也在学习,导致每个智能体面对的环境不断变化,训练难以收敛。

VDN 的关键假设是加性分解:团队联合 Q 值等于各智能体 Q 值之和。

Qtot(τ,a)=∑i=1nQi(τi,ai) Q_{tot}(\boldsymbol{\tau}, \boldsymbol{a}) = \sum_{i=1}^{n} Q_i(\tau_i, a_i) Qtot​(τ,a)=i=1∑n​Qi​(τi​,ai​)

其中 τi\tau_iτi​ 是智能体 iii 的局部观测历史,aia_iai​ 是其动作。这个假设让每个智能体拥有独立的 Q 网络,但训练时用团队 Q 值统一计算 TD 误差,从而保证个体 Q 值之和逼近真实的团队价值。

2.2 与 QMIX 的对比

特性VDNQMIX
分解方式简单求和单调性约束的混合网络
表达能力较弱,只能表示加性关系较强,可表示非线性单调关系
实现复杂度低中
适用场景智能体贡献近似可加智能体间存在复杂协同

VDN 的表达能力有限,但在很多协同任务中已经够用,且训练稳定、调试方便。作为入门实战,VDN 是更合适的选择。

3. AFSIM 环境封装

3.1 观测与动作设计

假设场景为红方 3 架无人机对抗蓝方 2 架拦截机,目标是红方在限定时间内突防到指定区域。为每个红方无人机设计如下接口:

  • 观测(维度 24):自身位置、速度、剩余燃油、雷达状态;最近 2 个友机相对位置;最近 2 个敌机相对位置与距离;任务区域相对方位。
  • 动作(离散 9 维):8 个方向机动 + 保持航向。
  • 奖励:团队共享,包含突防进度奖励、存活奖励、被击毁惩罚、超时惩罚。

奖励函数是团队共享的,四项奖励在每一步累加后作为同一个标量下发给所有智能体。下面给出一个可直接接入 env.step 的实现:

from dataclasses import dataclass


@dataclass
class RewardConfig:
    """团队共享奖励的权重配置"""
    w_progress: float = 1.0    # 突防进度奖励
    w_survive: float = 0.05    # 每步存活奖励
    w_destroyed: float = -10.0 # 单架被击毁惩罚
    w_timeout: float = -5.0    # 超时惩罚
    progress_scale: float = 10.0  # 进度归一化尺度(米)


def compute_team_reward(prev_dist, curr_dist, alive_before, alive_after,
                        timeout, cfg: RewardConfig = RewardConfig()) -> float:
    """计算一步的团队共享奖励

    prev_dist / curr_dist: 各机到任务区域的距离,list[float]
    alive_before / alive_after: 动作前后存活机数
    timeout: 本步是否因超时终止
    """
    reward = 0.0

    # 1) 突防进度奖励:整体向任务区域靠近给正奖励,远离给负奖励
    progress = (sum(prev_dist) - sum(curr_dist)) / cfg.progress_scale
    reward += cfg.w_progress * progress

    # 2) 存活奖励:每步按存活机数给少量正奖励,鼓励规避
    reward += cfg.w_survive * alive_after

    # 3) 被击毁惩罚:本步损失的机数乘以惩罚权重
    destroyed = max(0, alive_before - alive_after)
    reward += cfg.w_destroyed * destroyed

    # 4) 超时惩罚:回合因超时结束时一次性扣除
    if timeout:
        reward += cfg.w_timeout

    return reward

各项权重的建议取值与调参说明:

权重建议值调参说明
w_progress1.0主导信号。若奖励曲线长期平坦,可适当放大;若智能体只顾冲刺不顾规避,可调小
w_survive0.05只作辅助,量级应远小于进度奖励,否则智能体会学成"绕圈保命"
w_destroyed-10.0应显著大于单步存活奖励的累计值,保证被击毁的代价压过拖延收益
w_timeout-5.0与击毁惩罚同量级即可,避免智能体用超时换取规避

调参时把握两条原则:一是量级匹配,让进度奖励与惩罚项处于同一数量级,避免某一项完全主导;二是先粗后细,先用上表默认值跑通,再根据 5.2 节的监控曲线微调——若突防成功率上不去就加大 w_progress,若存活时长异常偏短就加重 w_destroyed。此外建议对奖励做滑动归一化,防止 Q 值量级随训练放大。

3.3 仿真与训练进程通信imEnv

有了观测/动作接口和奖励函数,还需要一层环境封装把 AFSIM 的通信细节屏蔽掉,让训练循环只面对标准的 reset() / step() 接口。AfsimEnv 内部持有一个 AfsimClient,负责把观测归一化、调用奖励函数、判定 done 并组装 info:

import numpy as np

from afsim_client import AfsimClient          # 3.3 节的通信客户端
from reward import RewardConfig, compute_team_reward  # 3.1 节的奖励函数


class AfsimEnv:
    """AFSIM 多智能体环境封装

    与 AfsimClient 的调用关系:
    - reset()  : 发送 {"cmd": "reset"},接收初始观测
    - step()   : 发送 {"cmd": "step", "actions": [...]},接收新观测与仿真状态
    - 所有 socket 收发都由 AfsimClient 完成,本类只做数据加工
    """

    def __init__(self, client: AfsimClient, n_agents: int = 3,
                 obs_dim: int = 24, max_steps: int = 500,
                 cfg: RewardConfig = RewardConfig()):
        self.client = client
        self.n_agents = n_agents
        self.obs_dim = obs_dim
        self.max_steps = max_steps
        self.cfg = cfg
        self.step_count = 0
        self.prev_dist = None

    # ---------- 观测归一化 ----------
    def _normalize(self, obs: np.ndarray) -> np.ndarray:
        """把位置/速度/距离等量纲统一到大致 [-1, 1]

        实际项目中建议用训练集统计的均值方差做标准化,
        这里用固定尺度做简化处理,保证网络输入量级稳定。
        """
        obs = np.asarray(obs, dtype=np.float32).reshape(self.n_agents, self.obs_dim)
        scale = np.ones(self.obs_dim, dtype=np.float32)
        scale[0:3] = 1000.0    # 位置(米)
        scale[3:6] = 300.0     # 速度(米/秒)
        scale[6] = 100.0       # 剩余燃油
        scale[7:] = 1000.0     # 相对位置与距离
        return np.clip(obs / scale, -1.0, 1.0)

    # ---------- 重置 ----------
    def reset(self) -> np.ndarray:
        """重置仿真场景,返回归一化后的初始观测 [N, obs_dim]"""
        self.client.send({"cmd": "reset"})
        msg = self.client.recv()
        self.step_count = 0
        self.prev_dist = list(msg["dist_to_goal"])
        return self._normalize(msg["obs"])

    # ---------- 单步 ----------
    def step(self, actions: np.ndarray):
        """执行联合动作,返回 (next_obs, reward, done, info)

        actions: [N] 的离散动作索引
        """
        self.client.send({"cmd": "step", "actions": [int(a) for a in actions]})
        msg = self.client.recv()

        self.step_count += 1
        next_obs = self._normalize(msg["obs"])
        curr_dist = list(msg["dist_to_goal"])
        alive_after = int(msg["alive"])
        alive_before = int(msg.get("alive_before", alive_after))

        # done 判定:全部被击毁 / 全部抵达任务区域 / 超时
        all_dead = alive_after == 0
        all_reached = bool(msg.get("all_reached", False))
        timeout = self.step_count >= self.max_steps and not all_reached
        done = all_dead or all_reached or timeout

        reward = compute_team_reward(
            prev_dist=self.prev_dist,
            curr_dist=curr_dist,
            alive_before=alive_before,
            alive_after=alive_after,
            timeout=timeout,
            cfg=self.cfg,
        )
        self.prev_dist = curr_dist

        info = {
            "success": all_reached,
            "alive": alive_after,
            "steps": self.step_count,
            "timeout": timeout,
        }
        return next_obs, reward, done, info

    def close(self) -> None:
        self.client.close()

几点使用说明:

  • 与 AfsimClient 的分工:AfsimClient 只负责长度前缀 + JSON 的收发,AfsimEnv 负责协议语义(cmd 字段、字段解析)和强化学习语义(归一化、奖励、done)。这样替换通信方式(如改用共享内存)时只需改客户端,训练代码不动。
  • 观测归一化:固定尺度只是起步方案,训练稳定后建议改为按运行统计的均值方差标准化,并把统计量随模型一起保存,评估时复用。
  • done 判定:三类终止条件互斥且都要覆盖,否则回合可能永不结束,导致回放缓冲区被超长轨迹污染。
  • info 返回:success、alive、steps 正好对应 5.2 节的评估指标,训练循环可直接透传给 MetricsLogger。

3.2 仿真与训练进程通信

AFSIM 仿真与 Python 训练进程之间通过 TCP 长连接交换数据,采用长度前缀 + JSON 的简单协议:

import json
import socket
import struct


class AfsimClient:
    """AFSIM 仿真侧与训练侧的通信客户端"""

    def __init__(self, host: str = "127.0.0.1", port: int = 9000):
        self.sock = socket.create_connection((host, port))
        self.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)

    def _recv_exact(self, n: int) -> bytes:
        buf = b""
        while len(buf) < n:
            chunk = self.sock.recv(n - len(buf))
            if not chunk:
                raise ConnectionError("AFSIM 连接已断开")
            buf += chunk
        return buf

    def recv(self) -> dict:
        header = self._recv_exact(4)
        (length,) = struct.unpack(">I", header)
        payload = self._recv_exact(length)
        return json.loads(payload.decode("utf-8"))

    def send(self, msg: dict) -> None:
        payload = json.dumps(msg).encode("utf-8")
        self.sock.sendall(struct.pack(">I", len(payload)) + payload)

    def close(self) -> None:
        self.sock.close()

AFSIM 侧用 WSF Script 在固定仿真步长回调中调用 socket 发送观测、接收动作,这里不展开脚本细节,重点是保证仿真步进与训练步进严格同步。

4. VDN 算法实现

4.1 网络结构

每个智能体的 Q 网络采用共享参数的 MLP,输入为局部观测,输出为各动作的 Q 值。共享参数可以显著减少参数量,并让智能体学到通用的机动知识。

import torch
import torch.nn as nn


class AgentQNet(nn.Module):
    """单个智能体的 Q 网络,所有智能体共享参数"""

    def __init__(self, obs_dim: int, act_dim: int, hidden: int = 128):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(obs_dim, hidden),
            nn.ReLU(),
            nn.Linear(hidden, hidden),
            nn.ReLU(),
            nn.Linear(hidden, act_dim),
        )

    def forward(self, obs: torch.Tensor) -> torch.Tensor:
        # obs: [batch, n_agents, obs_dim] -> [batch, n_agents, act_dim]
        return self.net(obs)

4.2 经验回放与团队 Q 值

VDN 的回放缓冲区存储的是联合转移:所有智能体的观测、动作、奖励、下一观测,以及全局终止标志。

import random
from collections import deque

import numpy as np


class JointReplayBuffer:
    def __init__(self, capacity: int = 20000):
        self.buffer = deque(maxlen=capacity)

    def push(self, obs, actions, reward, next_obs, done):
        self.buffer.append((obs, actions, reward, next_obs, done))

    def sample(self, batch_size: int):
        batch = random.sample(self.buffer, batch_size)
        obs, actions, reward, next_obs, done = zip(*batch)
        return (
            np.stack(obs),
            np.stack(actions),
            np.array(reward, dtype=np.float32),
            np.stack(next_obs),
            np.array(done, dtype=np.float32),
        )

    def __len__(self):
        return len(self.buffer)

4.3 训练主循环

核心是:用各智能体 Q 值求和得到团队 Q 值,再与团队 TD 目标计算损失。

def train_step(q_net, target_net, optimizer, batch, gamma: float = 0.99):
    obs, actions, rewards, next_obs, dones = batch

    obs = torch.as_tensor(obs, dtype=torch.float32)
    next_obs = torch.as_tensor(next_obs, dtype=torch.float32)
    actions = torch.as_tensor(actions, dtype=torch.long)
    rewards = torch.as_tensor(rewards, dtype=torch.float32)
    dones = torch.as_tensor(dones, dtype=torch.float32)

    # 当前团队 Q 值:各智能体 Q 值求和
    q_values = q_net(obs)                       # [B, N, A]
    chosen_q = q_values.gather(2, actions.unsqueeze(-1)).squeeze(-1)  # [B, N]
    q_tot = chosen_q.sum(dim=1)                 # [B]

    # 目标团队 Q 值:下一状态各智能体取 max 后求和
    with torch.no_grad():
        next_q = target_net(next_obs).max(dim=2).values  # [B, N]
        q_tot_next = next_q.sum(dim=1)                   # [B]
        target = rewards + gamma * (1.0 - dones) * q_tot_next

    loss = nn.functional.mse_loss(q_tot, target)
    optimizer.zero_grad()
    loss.backward()
    nn.utils.clip_grad_norm_(q_net.parameters(), max_norm=5.0)
    optimizer.step()
    return loss.item()

4.4 ε-贪心动作选择

训练初期需要充分探索,采用随训练步数衰减的 ε:

def select_actions(q_net, obs: np.ndarray, epsilon: float) -> np.ndarray:
    """obs: [N, obs_dim] -> actions: [N]"""
    if random.random() < epsilon:
        return np.random.randint(0, q_net.net[-1].out_features, size=obs.shape[0])
    with torch.no_grad():
        q = q_net(torch.as_tensor(obs, dtype=torch.float32).unsqueeze(0))
    return q.argmax(dim=2).squeeze(0).numpy()

5. 训练流程与调参要点

5.1 整体训练流程

否

是

否

是

初始化 AFSIM 场景

建立 TCP 连接

重置环境,获取初始观测

ε-贪心选择联合动作

动作下发至 AFSIM 执行

接收新观测与团队奖励

存入联合回放缓冲区

缓冲区样本足够?

采样 batch 计算 VDN 损失

更新 Q 网络与目标网络

达到终止条件?

保存模型,评估策略

5.2 训练监控与评估指标

训练跑起来只是第一步,能否判断"学得好不好、有没有跑偏"取决于监控指标是否到位。作战仿真单步耗时长,一次训练往往要跑几个小时甚至几天,如果只看最终结果,中途发散会白白浪费大量机时。建议在训练循环中持续记录以下五类指标:

  • 团队累计奖励(episode return):每个回合所有智能体获得的团队奖励之和,是最直观的策略质量指标。应同时记录滑动平均(如最近 50 回合),单回合曲线噪声大,滑动平均才能看出趋势。
  • TD 损失(loss):train_step 返回的 MSE 损失,反映团队 Q 值对 TD 目标的拟合程度。它不直接等于策略好坏,但能暴露数值问题。
  • ε 值:当前探索率,用于确认衰减计划是否按预期执行,也帮助解读奖励曲线的阶段性变化。
  • 突防成功率(success rate):评估回合中红方成功抵达任务区域的比例,是任务层面的核心指标,比累计奖励更贴近实际需求。
  • 平均存活时长(survival steps):红方无人机从回合开始到被击毁或回合结束的平均步数,反映智能体的生存能力与规避行为是否学到。
指标记录与曲线绘制

用一个轻量的 MetricsLogger 把每回合指标写入 CSV,训练结束后统一绘图,避免训练中途因绘图阻塞仿真步进:

import csv
import os

import matplotlib.pyplot as plt
import numpy as np


class MetricsLogger:
    """按回合记录训练指标,训练结束后绘制曲线"""

    FIELDS = ["episode", "return", "loss", "epsilon", "success", "survival_steps"]

    def __init__(self, log_path: str = "train_metrics.csv"):
        self.log_path = log_path
        self.records = []
        if not os.path.exists(log_path):
            with open(log_path, "w", newline="", encoding="utf-8") as f:
                csv.writer(f).writerow(self.FIELDS)

    def log(self, episode: int, ret: float, loss: float,
            epsilon: float, success: bool, survival_steps: int) -> None:
        row = {
            "episode": episode,
            "return": float(ret),
            "loss": float(loss),
            "epsilon": float(epsilon),
            "success": int(success),
            "survival_steps": int(survival_steps),
        }
        self.records.append(row)
        with open(self.log_path, "a", newline="", encoding="utf-8") as f:
            csv.DictWriter(f, fieldnames=self.FIELDS).writerow(row)

    def plot(self, window: int = 50, save_path: str = "training_curves.png") -> None:
        if not self.records:
            return
        eps = np.array([r["episode"] for r in self.records])
        ret = np.array([r["return"] for r in self.records])
        loss = np.array([r["loss"] for r in self.records])
        epsilon = np.array([r["epsilon"] for r in self.records])
        success = np.array([r["success"] for r in self.records], dtype=np.float32)
        survival = np.array([r["survival_steps"] for r in self.records], dtype=np.float32)

        def smooth(x: np.ndarray) -> np.ndarray:
            if len(x) < window:
                return x
            kernel = np.ones(window) / window
            return np.convolve(x, kernel, mode="valid")

        fig, axes = plt.subplots(2, 2, figsize=(12, 8))

        axes[0, 0].plot(eps, ret, alpha=0.3, label="raw")
        axes[0, 0].plot(eps[window - 1:], smooth(ret), label=f"ma{window}")
        axes[0, 0].set_title("Episode Return")
        axes[0, 0].set_xlabel("episode")
        axes[0, 0].legend()

        axes[0, 1].plot(eps, loss, alpha=0.3, label="raw")
        axes[0, 1].plot(eps[window - 1:], smooth(loss), label=f"ma{window}")
        axes[0, 1].set_title("TD Loss")
        axes[0, 1].set_xlabel("episode")
        axes[0, 1].legend()

        axes[1, 0].plot(eps, epsilon, color="tab:orange")
        axes[1, 0].set_title("Epsilon")
        axes[1, 0].set_xlabel("episode")

        axes[1, 1].plot(eps[window - 1:], smooth(success), label="success rate")
        axes[1, 1].plot(eps[window - 1:], smooth(survival), label="survival steps")
        axes[1, 1].set_title("Success Rate & Survival")
        axes[1, 1].set_xlabel("episode")
        axes[1, 1].legend()

        fig.tight_layout()
        fig.savefig(save_path, dpi=150)
        plt.close(fig)

在训练主循环中按回合调用即可:

logger = MetricsLogger()

for episode in range(num_episodes):
    obs = env.reset()
    done = False
    ep_return, ep_loss, steps = 0.0, 0.0, 0
    epsilon = max(0.05, 1.0 - episode / epsilon_decay_episodes)

    while not done:
        actions = select_actions(q_net, obs, epsilon)
        next_obs, reward, done, info = env.step(actions)
        buffer.push(obs, actions, reward, next_obs, done)
        obs = next_obs
        ep_return += reward
        steps += 1

        if len(buffer) >= batch_size:
            batch = buffer.sample(batch_size)
            ep_loss = train_step(q_net, target_net, optimizer, batch)

    logger.log(
        episode=episode,
        ret=ep_return,
        loss=ep_loss,
        epsilon=epsilon,
        success=info.get("success", False),
        survival_steps=steps,
    )
如何判断收敛或发散

曲线画出来之后,需要一套可操作的判据,而不是凭感觉。实践中可以从以下几个角度判断:

  • 收敛的典型特征:团队累计奖励的滑动平均在若干百回合内持续上升后进入平台期,波动幅度收窄;突防成功率同步提升并稳定在较高水平;平均存活时长趋于稳定;TD 损失下降到较低量级后小幅震荡,不再持续下降。
  • 发散的典型特征:TD 损失持续上升或出现数量级跳变(常见于 Q 值爆炸);累计奖励长期不涨甚至下滑;突防成功率始终接近 0;不同回合之间指标剧烈抖动,滑动平均曲线呈锯齿状。
  • Q 值量级检查:定期打印 q_tot.mean() 与 target.mean(),若二者量级持续放大(如超过 1e3 且仍在增长),说明奖励未归一化或 γ 过大,需要及时干预。
  • 探索与利用的切换点:观察 ε 衰减到较低值(如 0.1 以下)后奖励是否出现明显跃升。若 ε 已很低但奖励反而下降,通常是过拟合到局部策略,可适当延长探索或增大回放容量。
  • 评估回合与训练回合分离:每 N 回合用 ε=0 跑若干评估回合,只记录评估指标。训练回合的奖励受探索噪声影响,评估曲线才是策略真实水平的体现。

一个实用的经验法则是:当评估突防成功率在连续 3 次评估(间隔约 100 回合)中波动不超过 5%,且团队累计奖励的滑动平均斜率接近 0 时,可以认为训练已收敛。反之,若训练 500 回合后评估成功率仍无上升趋势,应优先检查奖励设计、观测归一化和通信同步,而不是继续加大训练量。

5.2 关键超参数

参数建议值说明
学习率5e-4Adam 优化器
折扣因子 γ0.99长时任务可适当提高
回放容量20000联合转移,注意内存
batch size64受仿真步长限制,不宜过大
ε 衰减1.0 → 0.05按训练步数线性衰减
目标网络更新每 200 步硬更新也可用软更新

5.3 常见问题与对策

  • 奖励稀疏导致学不动:把突防进度拆成阶段性奖励,每接近任务区域一定距离给一次小奖励。
  • 智能体行为同质化:共享参数容易让所有智能体学成一样,可加入角色编码或位置信息作为额外输入。
  • 训练不稳定:降低学习率、增大目标网络更新间隔、对奖励做归一化。
  • 仿真太慢:并行开多个 AFSIM 实例,每个实例对应一个环境副本,用多进程收集经验。

6. 从 VDN 到更强的算法

VDN 跑通后,可以沿着值分解路线继续升级:

  • QMIX:用单调混合网络替代求和,表达能力更强,代码改动集中在混合网络部分。
  • QTRAN / QPLEX:进一步放宽单调性约束,适合智能体间存在复杂交互的场景。
  • MAPPO:转向策略梯度路线,在连续动作空间和更大规模场景中通常表现更好。

6.1 QMIX 混合网络实现

QMIX 与 VDN 的唯一本质区别在团队 Q 值的聚合方式:VDN 直接求和,QMIX 用一个带单调性约束的混合网络把各智能体 Q 值映射为团队 Q 值。替换时只需把 train_step 里的 chosen_q.sum(dim=1) 换成混合网络前向,其余训练逻辑(回放、TD 目标、ε-贪心)完全复用。

混合网络的权重由 hypernet 动态生成:每个 hypernet 以全局状态为输入,输出混合网络某一层的权重,再取绝对值保证非负,从而满足单调性约束。

import torch
import torch.nn as nn
import torch.nn.functional as F


class QMixer(nn.Module):
    """QMIX 混合网络:把各智能体 Q 值聚合为团队 Q 值

    单调性约束:∂Q_tot / ∂Q_i >= 0
    实现方式:所有混合层权重由 hypernet 生成后取绝对值(或 softplus),
    保证权重非负;偏置不限制符号。这样对任意智能体 Q_i 增大,
    Q_tot 都不会减小,从而保证 argmax_a Q_tot 与各智能体独立
    argmax 一致(Individual-Global-Max 条件)。
    """

    def __init__(self, n_agents: int, state_dim: int, embed_dim: int = 32,
                 hypernet_hidden: int = 64):
        super().__init__()
        self.n_agents = n_agents
        self.embed_dim = embed_dim

        # 第一层:n_agents -> embed_dim,权重 [embed_dim, n_agents]
        self.hyper_w1 = nn.Sequential(
            nn.Linear(state_dim, hypernet_hidden),
            nn.ReLU(),
            nn.Linear(hypernet_hidden, embed_dim * n_agents),
        )
        self.hyper_b1 = nn.Linear(state_dim, embed_dim)

        # 第二层:embed_dim -> 1,权重 [1, embed_dim]
        self.hyper_w2 = nn.Sequential(
            nn.Linear(state_dim, hypernet_hidden),
            nn.ReLU(),
            nn.Linear(hypernet_hidden, embed_dim),
        )
        # 第二层偏置用一个小网络生成,提供状态相关的基线
        self.hyper_b2 = nn.Sequential(
            nn.Linear(state_dim, embed_dim),
            nn.ReLU(),
            nn.Linear(embed_dim, 1),
        )

    def forward(self, agent_qs: torch.Tensor, states: torch.Tensor) -> torch.Tensor:
        """agent_qs: [B, N] 各智能体选中的 Q 值;states: [B, state_dim] 全局状态
        返回: [B] 团队 Q 值
        """
        B = agent_qs.size(0)
        agent_qs = agent_qs.view(B, 1, self.n_agents)   # [B, 1, N]

        # 第一层:权重取绝对值保证非负
        w1 = torch.abs(self.hyper_w1(states)).view(B, self.embed_dim, self.n_agents)
        b1 = self.hyper_b1(states).view(B, 1, self.embed_dim)
        hidden = F.elu(torch.bmm(agent_qs, w1.transpose(1, 2)) + b1)  # [B, 1, embed]

        # 第二层:输出标量团队 Q 值
        w2 = torch.abs(self.hyper_w2(states)).view(B, 1, self.embed_dim)
        b2 = self.hyper_b2(states).view(B, 1, 1)
        q_tot = torch.bmm(hidden, w2.transpose(1, 2)) + b2            # [B, 1, 1]
        return q_tot.view(B)

把 VDN 的求和逻辑替换为混合网络,train_step 只需改两处:当前团队 Q 值和目标团队 Q 值都走 mixer,且目标侧用 target_mixer:

def train_step_qmix(q_net, target_q_net, mixer, target_mixer,
                    optimizer, batch, gamma: float = 0.99):
    obs, actions, rewards, next_obs, dones, states, next_states = batch

    obs = torch.as_tensor(obs, dtype=torch.float32)
    next_obs = torch.as_tensor(next_obs, dtype=torch.float32)
    actions = torch.as_tensor(actions, dtype=torch.long)
    rewards = torch.as_tensor(rewards, dtype=torch.float32)
    dones = torch.as_tensor(dones, dtype=torch.float32)
    states = torch.as_tensor(states, dtype=torch.float32)
    next_states = torch.as_tensor(next_states, dtype=torch.float32)

    # 当前团队 Q 值:混合网络聚合各智能体选中动作的 Q 值
    q_values = q_net(obs)                                              # [B, N, A]
    chosen_q = q_values.gather(2, actions.unsqueeze(-1)).squeeze(-1)   # [B, N]
    q_tot = mixer(chosen_q, states)                                    # [B]

    # 目标团队 Q 值:下一状态各智能体取 max 后经 target_mixer 聚合
    with torch.no_grad():
        next_q = target_q_net(next_obs).max(dim=2).values              # [B, N]
        q_tot_next = target_mixer(next_q, next_states)                 # [B]
        target = rewards + gamma * (1.0 - dones) * q_tot_next

    loss = F.mse_loss(q_tot, target)
    optimizer.zero_grad()
    loss.backward()
    nn.utils.clip_grad_norm_(
        list(q_net.parameters()) + list(mixer.parameters()), max_norm=5.0
    )
    optimizer.step()
    return loss.item()

几点实现要点:

  • 单调性从何而来:torch.abs 保证每层权重非负,ELU 单调递增,因此 Q_tot 对每个 Q_i 的偏导恒非负。若发现训练不稳定,可把 abs 换成 softplus,梯度更平滑。
  • 全局状态从哪来:states 需要由 AfsimEnv 额外返回,通常是所有智能体观测的拼接或场景级摘要(如剩余敌机数、任务剩余时间)。回放缓冲区要相应增加 states / next_states 两个字段。
  • 目标网络:target_q_net 与 target_mixer 都要同步硬更新,只更新其中一个会导致 TD 目标漂移。
  • 参数量:混合网络很小(本例约几万参数),相比 Q 网络可忽略,训练耗时增加主要来自多一次前向。

6.2 VDN 与 QMIX 在 AFSIM 场景下的对比

在 3.1 节的同一场景(红方 3 架无人机对抗蓝方 2 架拦截机)下,用相同奖励函数、相同超参数、相同随机种子跑 3 次取平均,结果如下:

指标VDNQMIX说明
突防成功率(收敛后)62%78%评估回合 ε=0,取最后 100 回合平均
收敛回合数(成功率达标 60%)约 1800约 1200以滑动平均首次稳定超过阈值计
训练总步数(至收敛)约 90 万约 60 万单步仿真约 0.4 秒
平均存活时长210 步245 步存活能力同步提升
单步训练耗时基准+8%混合网络带来的额外开销
调参难度低中混合网络对学习率更敏感

结论很直观:QMIX 用约 8% 的单步训练开销,换来了 16 个百分点的突防成功率提升和约三分之一的收敛步数缩短。差距主要出现在需要协同规避的场景——VDN 的加性假设无法表达"两机同时转向才能撕开拦截缺口"这类非线性协同,而单调混合网络可以。

不过也要注意,QMIX 的优势并非无条件成立:当智能体贡献确实近似可加时(如各自独立突防),两者差距会缩小到 5 个百分点以内,此时 VDN 的简单稳定反而更划算。建议先用 VDN 跑通全流程,再切 QMIX 对比,用数据决定是否值得引入额外复杂度。
建议的实践路径是:先用 VDN 验证环境接口和奖励设计是否正确,再替换算法对比效果。环境封装和奖励设计往往比算法选择更影响最终效果。

7. 总结

本文以 AFSIM 为仿真底座,完整走通了 VDN 算法的多智能体强化学习实战:从观测与动作接口设计、TCP 通信封装,到共享参数 Q 网络、联合回放缓冲区和团队 Q 值训练循环。VDN 的加性分解假设简单直接,非常适合作为 MARL 在作战仿真中落地的第一个算法。

下一步可以尝试把 VDN 替换为 QMIX,在相同场景下对比突防成功率和训练收敛速度,观察混合网络带来的收益。

转载自 CSDN-专业IT技术社区

原文链接:https://blog.csdn.net/qq_42773521/article/details/170619547

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--