从DDPG到MADDPG:多智能体强化学习的演进与实践

强化学习:DDPG到MADDPG 本文主要关注于强化学习中基于策略梯度的方法。首先会简要介绍什么是策略梯度,什么是Actor-Critic算法,之后会重点讲述DDPG(Deep Deterministic Policy Gradient)算法,以及DDPG的多智能体版本:MADDG(Multi-agent Deep Deterministic Policy Gradient)。 策略梯度(Policy Gradient) 与基于策略梯度(Policy Based)的方法相对应的,是基于动作价值函数(Value Based)的方法。我们熟 阅读详情

1. 从单打独斗到团队协作:为什么我们需要多智能体强化学习?

大家好,我是老张,在AI和机器人领域摸爬滚打了十几年。今天想和大家聊聊一个特别有意思的话题:多智能体强化学习。你可能听说过AlphaGo下围棋很厉害,或者见过一些能自己走迷宫的机器人,这些都是单智能体强化学习的杰作。但现实世界远比这复杂,想想看,一队足球机器人怎么配合进攻?一群自动驾驶汽车如何在十字路口高效、安全地通行?这些场景里,每个个体(智能体)不仅要和环境“斗智斗勇”,还要和其他同样在学习的个体互动。这就是多智能体强化学习要解决的难题。

我刚开始接触这个领域时,也犯过很多新手会犯的错误:直接把训练单个机器人的方法,比如经典的DQN或者策略梯度,套用到多个机器人上。结果呢?训练过程极其不稳定,要么是几个智能体互相“打架”,谁也别想学到东西;要么是陷入局部最优,比如在合作搬运任务中,所有智能体都挤在同一个角落,谁也动不了。这让我意识到,多智能体环境是一个“非平稳”的环境——对任何一个智能体来说,它学习时面对的“环境规则”一直在变,因为其他智能体也在学习、在改变策略。这就好比你在学打乒乓球,但你的对手每天都在以惊人的速度进步,你昨天总结的制胜策略,今天可能就完全失效了。

所以,从单智能体到多智能体,绝不仅仅是把算法复制粘贴几份那么简单。它需要全新的设计思路。早期的尝试,比如让每个智能体独立运行一个DQN(我们称之为IQL),在简单的合作任务中可能还行,但一旦涉及到竞争或者复杂的混合动机,就彻底歇菜了。后来,大家想到了“集中训练,分散执行”这个天才的思路。简单说,就是在训练的时候,我们开个“上帝视角”,知道所有智能体的观察和动作,用一个更强大的“大脑”来指导每个个体学习;但实际执行任务时,每个智能体只依靠自己的局部观察来行动,就像足球队员在场上只能看到自己视野范围内的信息,但平时的战术训练却是教练基于全场录像分析的。这个思路,正是我们今天要深入探讨的MADDPG算法的核心。而MADDPG,又是在一个非常强大的单智能体算法——DDPG的基础上演化而来的。要理解MADDPG的精妙,我们必须先吃透DDPG。

2. 基石篇:深入理解DDPG算法

在聊多智能体之前,我们必须把单智能体的基础打牢。DDPG,全称深度确定性策略梯度,可以说是解决连续动作空间控制问题的里程碑式算法。我最早用它来训练机械臂抓取物体,效果比之前用的方法好太多了。

2.1 策略梯度与Actor-Critic:从随机到确定

要搞懂DDPG,我们得先往回退两步。传统的策略梯度方法,比如REINFORCE,输出的是一个动作的概率分布。比如,机械臂的关节角度是一个连续值,策略网络会输出一个均值和一个方差,表示在这个状态下,每个关节角度应该服从一个怎样的高斯分布。然后我们从这个分布里采样一个具体角度去执行。这种方法很直观,叫做随机性策略。但它有个问题:采样带来的方差很大,导致训练不稳定,学习速度慢。

于是就有了Actor-Critic架构。你可以把它想象成一个“演员-评论家”系统。Actor(演员) 就是策略网络,负责根据当前状态做动作。Critic(评论家) 是一个价值网络,负责评价Actor刚才那个动作做得好不好,给出一个分数(Q值)。Actor的目标就是做出能让Critic打高分的动作。这个架构实现了单步更新,比等到一个回合结束再更新的蒙特卡洛方法高效多了。

但即使是Actor-Critic,早期版本大多还是输出随机策略。直到确定性策略梯度定理被证明,事情才有了转机。DPG算法提出,我们可以让Actor直接输出一个确定的动作值,而不是一个概率分布。比如,状态是“目标物体在正前方30厘米”,Actor就直接输出“关节1转动45度,关节2转动30度”这样一个具体的向量。这就是确定性策略。它的最大好处是,在计算策略梯度时,原本需要对动作空间进行积分(计算期望),现在因为策略是确定的,这个积分被简化了,只需要对状态空间求导,效率高了很多,需要的样本也更少。

2.2 DDPG的核心机制与实现“坑点”

DDPG就是把DPG的思想和深度神经网络结合起来,并且借鉴了DQN的成功经验。它一共维护了四个神经网络,这是理解它的关键:

  1. Actor当前网络:这是我们正在训练的策略网络,输入状态,输出确定的动作。
  2. Critic当前网络:这是我们正在训练的价值网络,输入状态和动作,输出一个Q值,评价这个状态-动作对的好坏。
  3. Actor目标网络:它是Actor当前网络的一个“慢拷贝”,用于计算目标值时选择下一个动作,起到稳定训练的作用。
  4. Critic目标网络:同样是Critic当前网络的“慢拷贝”,用于计算目标Q值。

这里的目标网络和DQN里的思路一样,都是为了打破数据之间的相关性,让训练更稳定。DDPG用了一种叫“软更新”的方式,每次只把当前网络的一小部分参数更新到目标网络:θ_target = τ * θ_current + (1-τ) * θ_target,其中τ是一个很小的数,比如0.001。这样目标网络的变化就很缓慢,像一个锚一样稳定着训练过程。

经验回放池也是从DQN继承来的法宝。智能体把每一步交互的经验(状态,动作,奖励,下一个状态,是否结束)存到一个大缓冲池里。训练时,随机从池子里抽出一批数据来用。这样做有两个好处:一是打破了数据的时间关联性,二是让同一份数据可以被反复学习,提高了数据利用率。

在实际写代码实现时,我踩过几个典型的“坑”。首先是探索问题。因为策略是确定性的,如果一开始Actor网络参数初始化得不好,它可能只会输出一个很小范围内的动作,导致根本无法探索到那些能获得高奖励的区域。DDPG的解决方案很巧妙:给Actor输出的动作加上噪声。我常用的是一种叫做奥恩斯坦-乌伦贝克过程的噪声,它比简单的高斯噪声更好,因为具有时间相关性,有点像动量,能让探索动作更平滑,更适合物理控制任务。在代码里,大概长这样:

import numpy as np

class OUNoise:
    def __init__(self, action_dim, mu=0, theta=0.15, sigma=0.2):
        self.action_dim = action_dim
        self.mu = mu
        self.theta = theta
        self.sigma = sigma
        self.state = np.ones(self.action_dim) * self.mu
        self.reset()

    def reset(self):
        self.state = np.ones(self.action_dim) * self.mu

    def sample(self):
        x = self.state
        dx = self.theta * (self.mu - x) + self.sigma * np.random.randn(self.action_dim)
        self.state = x + dx
        return self.state

# 在训练时,动作 = Actor网络输出 + OU噪声样本
action = actor(state) + noise.sample()
action = np.clip(action, -1, 1)  # 假设动作范围在[-1,1]

第二个“坑”是网络更新顺序和损失函数。Critic的损失和DQN类似,是均方误差损失:L = mean( (Q_target - Q_current)^2 ),其中 Q_target = r + γ * Q_target(s_next, Actor_target(s_next))。这里注意,下一个动作是用Actor目标网络生成的。

Actor的损失函数则比较特别:L = - mean( Q_current(s, Actor_current(s)) )。也就是说,Actor的目标是最大化Critic对当前状态和它自己输出动作所给出的Q值。因此,我们在计算Actor的梯度时,需要让Q值对Actor的参数求导,并沿着梯度上升的方向更新。在PyTorch里,这通常意味着我们需要先计算Critic关于动作的梯度,再传递给Actor。

# 假设 actor 和 critic 是当前网络,actor_target 和 critic_target 是目标网络
# states, actions, rewards, next_states, dones 是从回放池采样的一批数据

# 1. 更新Critic
with torch.no_grad():
    next_actions = actor_target(next_states)
    q_next = critic_target(next_states, next_actions)
    q_targets = rewards + gamma * q_next * (1 - dones)

q_expected = critic(states, actions)
critic_loss = F.mse_loss(q_expected, q_targets)
critic_optimizer.zero_grad()
critic_loss.backward()
critic_optimizer.step()

# 2. 更新Actor
actor_actions = actor(states)
actor_loss = -critic(states, actor_actions).mean()  # 注意这里的负号
actor_optimizer.zero_grad()
actor_loss.backward()
actor_optimizer.step()

# 3. 软更新目标网络
soft_update(actor_target, actor, tau)
soft_update(critic_target, critic, tau)

把这些“坑”填平后,DDPG在连续控制任务上,比如让机械臂到达指定位置、让模拟机器人行走等,表现非常出色。它为处理更复杂的多智能体问题奠定了坚实的技术基础。

3. 演进之路:从DDPG到MADDPG的设计哲学

当我们把DDPG这个强大的单智能体算法直接搬到多智能体环境中时,会发现它立刻“水土不服”。最核心的矛盾就是我开头提到的环境非平稳性。每个智能体都在独立学习,都在改变自己的行为策略。对于任何一个特定的智能体来说,其他智能体策略的改变,就相当于它所在的环境的动态模型发生了改变。这会导致一个严重的问题:经验回放池里存储的旧经验可能已经“过时”了。因为当时你记录的状态、动作和奖励,是基于其他智能体当时的策略,现在它们的策略变了,这些旧经验用来学习可能会产生误导。

MADDPG的论文作者很聪明地提出了“集中训练,分散执行”的框架来解决这个问题。这个框架的精髓在于,它巧妙地区分了训练和执行两个阶段,化解了非平稳性这个核心矛盾。

3.1 “集中训练,分散执行”框架详解

我们以两个智能体合作的场景为例。在训练阶段,我们假设有一个“中央教练”。这个教练拥有全局信息:他能看到所有智能体的观察(o1, o2)和所有智能体采取的动作(a1, a2)。每个智能体仍然有自己的Actor网络,这个网络在训练和执行时都一样,只能看到自己的局部观察oi,并输出自己的动作ai。关键在于,每个智能体还有一个Critic网络,这个Critic在训练时是特殊的:它的输入不仅仅是自己个体的状态和动作,而是所有智能体的观察和动作拼接起来的全局信息。

这样做有什么好处呢?首先,对于Critic来说,环境变得“平稳”了。因为它在学习评估一个动作的好坏时,是基于全局信息的,它知道其他智能体在干什么。即使其他智能体的策略在变,Critic在训练时看到的输入(全局状态和联合动作)始终是完整的、一致的。它要学习的映射关系是:给定一个全局状态和所有智能体的联合动作,预测会得到多少回报。这个映射关系本身是稳定的。

其次,在训练Actor时,我们利用这个拥有全局视角的Critic来指导。当我们计算智能体i的Actor的梯度时,我们固定其他智能体当前的策略,然后问Critic:“如果智能体i稍微改变一下它的动作,全局的Q值会怎么变化?”我们沿着能让全局Q值增加的方向去更新智能体i的Actor。因为Critic是基于全局信息做出判断的,所以这个更新方向是朝着对整体团队有利的方向进行的。

到了实际执行阶段,那个“中央教练”或者说全局视角就不需要了。每个智能体只需要自己的、已经训练好的Actor网络,根据自己局部的观察做出动作即可。这就是“分散执行”。整个框架的流程,我画了一个简化的示意图来帮助理解:

阶段智能体i的Actor输入智能体i的Critic输入目的
集中训练局部观察 o_i全局观察 (o1, o2, ...) 和 全局动作 (a1, a2, ...)利用全局信息稳定地学习一个能评价联合动作好坏的价值函数,并用它来指导每个局部策略的更新。
分散执行局部观察 o_i无需使用每个智能体仅凭自身观察独立行动,实现去中心化的协同。

3.2 MADDPG针对多智能体的独特优化

除了核心框架,MADDPG论文还提出了两个非常实用的技巧来应对多智能体环境中的特殊挑战。

第一个技巧是估计其他智能体的策略。 在完全竞争的环境里,比如下棋,知道对手的策略至关重要。MADDPG允许每个智能体i维护一个对其他智能体j的策略的估计网络。这个估计网络输入智能体j的观察,输出对j的动作的预测(在连续空间下,通常是预测一个高斯分布的参数)。在训练时,智能体i会用最大似然估计的方法来更新这个估计网络,让它预测的动作分布和智能体j历史动作的分布尽量接近。这样,在计算自己Actor的梯度时,即使没有中央教练提供其他智能体的真实动作,智能体i也可以用自己估计出来的动作来近似,使得算法在部分可观测或者需要建模对手的场景下依然有效。

第二个技巧是策略集成。 在多智能体环境中,尤其是竞争环境中,很容易出现“过拟合”现象。智能体i可能学了一个专门针对当前版本智能体j的策略,这个策略对j很有效,但极其脆弱。一旦j更新了自己的策略,i的策略就完全失效了。这就像在石头剪刀布游戏里,你发现对手总爱出石头,于是你一直出布,赢得很开心。但一旦对手发现这个规律,改成出剪刀,你就惨了。为了解决这个问题,MADDPG让每个智能体同时学习多个子策略。在每个训练回合开始时,随机选择一个子策略来用。这样,智能体学到的就不是一个单一的、脆弱的策略,而是一组策略。它的目标是最优化这组策略的平均表现。这大大增强了智能体的鲁棒性,让它能更好地应对其他智能体策略的变化。

4. 实战指南:用MADDPG解决经典协作与竞争问题

理论说得再多,不如动手跑一跑。这里我结合自己实现和调试MADDPG的经验,给大家剖析两个经典环境:合作导航和追逃游戏。我们使用PyTorch框架,环境可以用OpenAI的PettingZoo库或者MPE环境。

4.1 环境搭建与智能体定义

首先,我们定义一个通用的MADDPG智能体类,它包含了Actor、Critic以及它们对应的目标网络。

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np

class Actor(nn.Module):
    """策略网络,输入局部观察,输出确定动作"""
    def __init__(self, obs_dim, act_dim, hidden_size=256):
        super(Actor, self).__init__()
        self.fc1 = nn.Linear(obs_dim, hidden_size)
        self.fc2 = nn.Linear(hidden_size, hidden_size)
        self.fc3 = nn.Linear(hidden_size, act_dim)
        # 假设动作范围是[-1, 1],最后用tanh激活
        self.tanh = nn.Tanh()

    def forward(self, obs):
        x = F.relu(self.fc1(obs))
        x = F.relu(self.fc2(x))
        return self.tanh(self.fc3(x))

class Critic(nn.Module):
    """价值网络,在MADDPG中,输入是所有智能体的观察和动作的拼接"""
    def __init__(self, total_obs_dim, total_act_dim, hidden_size=256):
        super(Critic, self).__init__()
        # 注意输入维度是全局的
        self.fc1 = nn.Linear(total_obs_dim + total_act_dim, hidden_size)
        self.fc2 = nn.Linear(hidden_size, hidden_size)
        self.fc3 = nn.Linear(hidden_size, 1)  # 输出一个Q值标量

    def forward(self, global_obs, global_acts):
        # global_obs和global_acts已经是拼接好的张量
        x = torch.cat([global_obs, global_acts], dim=1)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        return self.fc3(x)

接下来是智能体类,它封装了一个Actor-Critic对以及经验回放、更新逻辑。

class MADDPGAgent:
    def __init__(self, agent_id, obs_dim, act_dim, total_obs_dim, total_act_dim, lr_actor=1e-4, lr_critic=1e-3):
        self.id = agent_id
        self.obs_dim = obs_dim
        self.act_dim = act_dim

        self.actor = Actor(obs_dim, act_dim)
        self.critic = Critic(total_obs_dim, total_act_dim)
        self.actor_target = Actor(obs_dim, act_dim)
        self.critic_target = Critic(total_obs_dim, total_act_dim)

        # 硬拷贝参数初始化目标网络
        self.actor_target.load_state_dict(self.actor.state_dict())
        self.critic_target.load_state_dict(self.critic.state_dict())

        self.actor_optimizer = torch.optim.Adam(self.actor.parameters(), lr=lr_actor)
        self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), lr=lr_critic)

        self.noise = OUNoise(act_dim)  # 探索噪声

    def act(self, obs, noise_scale=0.1):
        """根据观察选择动作,训练时加噪声,评估时不加"""
        obs = torch.FloatTensor(obs).unsqueeze(0)
        action = self.actor(obs).detach().numpy().squeeze(0)
        if noise_scale > 0:
            action += noise_scale * self.noise.sample()
        return np.clip(action, -1, 1)

4.2 核心训练循环与多智能体更新

最核心的部分在于多智能体的协同更新。我们需要一个MADDPG管理器来协调所有智能体。

class MADDPG:
    def __init__(self, n_agents, obs_dims, act_dims, gamma=0.95, tau=0.01):
        self.n_agents = n_agents
        self.gamma = gamma
        self.tau = tau
        self.total_obs_dim = sum(obs_dims)
        self.total_act_dim = sum(act_dims)

        # 创建N个智能体
        self.agents = [
            MADDPGAgent(i, obs_dims[i], act_dims[i], self.total_obs_dim, self.total_act_dim)
            for i in range(n_agents)
        ]
        self.replay_buffer = ReplayBuffer(capacity=1000000)  # 经验回放池

    def update(self, batch_size=256):
        """从回放池采样,更新所有智能体"""
        if len(self.replay_buffer) < batch_size:
            return

        # 采样一批经验
        obs_batch, act_batch, rew_batch, next_obs_batch, done_batch = self.replay_buffer.sample(batch_size)
        # 转换为PyTorch张量
        obs_batch = torch.FloatTensor(obs_batch)  # shape: [batch, n_agents, obs_dim]
        act_batch = torch.FloatTensor(act_batch)
        rew_batch = torch.FloatTensor(rew_batch)
        next_obs_batch = torch.FloatTensor(next_obs_batch)
        done_batch = torch.FloatTensor(done_batch)

        # 为每个智能体更新Critic和Actor
        for i, agent in enumerate(self.agents):
            # 1. 更新Critic
            agent.critic_optimizer.zero_grad()
            # 计算目标Q值
            with torch.no_grad():
                # 所有智能体的下一个动作(由目标Actor网络产生)
                next_acts_target = []
                for j in range(self.n_agents):
                    next_act_j = self.agents[j].actor_target(next_obs_batch[:, j, :])
                    next_acts_target.append(next_act_j)
                next_acts_target = torch.cat(next_acts_target, dim=1)  # 拼接全局动作

                # 拼接全局下一个观察
                next_obs_global = next_obs_batch.view(batch_size, -1)
                # 目标Critic网络计算Q值
                q_next = agent.critic_target(next_obs_global, next_acts_target).squeeze()
                q_target = rew_batch[:, i] + self.gamma * (1 - done_batch[:, i]) * q_next

            # 当前Critic网络计算Q值
            obs_global = obs_batch.view(batch_size, -1)
            acts_global = act_batch.view(batch_size, -1)
            q_current = agent.critic(obs_global, acts_global).squeeze()

            critic_loss = F.mse_loss(q_current, q_target)
            critic_loss.backward()
            agent.critic_optimizer.step()

            # 2. 更新Actor
            agent.actor_optimizer.zero_grad()
            # 固定其他智能体的Actor,计算当前智能体动作对全局Q值的影响
            current_acts = []
            for j in range(self.n_agents):
                if j == i:
                    # 对于当前智能体i,使用其Actor网络,并计算梯度
                    act_i = agent.actor(obs_batch[:, i, :])
                    current_acts.append(act_i)
                else:
                    # 对于其他智能体,使用它们当前的Actor网络,但不计算梯度(detach)
                    act_j = self.agents[j].actor(obs_batch[:, j, :]).detach()
                    current_acts.append(act_j)
            current_acts_global = torch.cat(current_acts, dim=1)

            actor_loss = -agent.critic(obs_global, current_acts_global).mean()
            actor_loss.backward()
            agent.actor_optimizer.step()

            # 3. 软更新目标网络
            self.soft_update(agent.actor, agent.actor_target)
            self.soft_update(agent.critic, agent.critic_target)

    def soft_update(self, local_model, target_model):
        for target_param, local_param in zip(target_model.parameters(), local_model.parameters()):
            target_param.data.copy_(self.tau * local_param.data + (1.0 - self.tau) * target_param.data)

4.3 在合作与竞争环境中的表现分析

在合作导航环境里,多个智能体需要学会分别移动到不同的地标位置,同时避免相互碰撞。使用独立DDPG(每个智能体只用自己的局部信息训练Critic)时,智能体们会显得非常“自私”和混乱,经常撞在一起,到达目标点的效率很低。而切换到MADDPG后,因为Critic在训练时能看到全局信息(所有智能体的位置和地标位置),它能更好地评估“协作”动作的价值。很快,智能体们就能学会分工,各自奔向不同的目标,并且路径规划也更合理,碰撞显著减少。你可以明显看到团队整体回报的快速提升和稳定。

在追逃游戏中,有两个追击者和两个逃跑者。追击者要合作抓住逃跑者,逃跑者则要合作躲避。这是一个典型的竞争与合作混合的场景。独立DDPG几乎无法让追击者形成有效的包围战术。而MADDPG,特别是结合了“估计其他智能体策略”的技巧后,追击者能够更好地预测逃跑者的动向,从而学会分头包抄、围堵。同时,逃跑者也能学会分散注意力、互相掩护。整个系统的策略会动态演化,非常有趣。如果再加上“策略集成”,智能体的策略会更加鲁棒,不容易被对手针对。

在实际调试中,超参数的选择至关重要。tau(软更新系数)通常设得很小(0.01或0.005),让目标网络缓慢变化。学习率上,Critic的学习率通常比Actor大一个数量级(例如1e-3 vs 1e-4),因为Critic需要更快地收敛来提供准确的指导。噪声的尺度需要随着训练进行而衰减,初期鼓励探索,后期鼓励利用。回放池的大小要足够容纳多样化的经验,我一般设置为50万到100万。

5. 超越MADDPG:前沿优化与未来挑战

MADDPG为多智能体深度强化学习打开了一扇大门,但它并非终点。在实际项目和应用中,我们还会遇到许多它无法直接解决的挑战,社区也提出了很多改进方向。

通信与注意力机制:MADDPG在训练时假设有全局信息,但这在很多现实场景中不成立,比如一群无人机只有有限的通信范围。后来的研究如CommNet、ATOC等,引入了智能体间的通信信道。智能体可以学习生成消息并发送给邻居,或者使用注意力机制(如Transformer)来动态决定关注哪些其他智能体的信息。我在一个分布式传感器网络的目标跟踪项目中就采用了基于注意力的方法,让每个节点只处理和它观测目标相关的其他节点的信息,大大降低了计算和通信开销。

信用分配问题:在多智能体合作任务中,团队获得了一个总的奖励,但如何公平地衡量每个智能体个体的贡献?这就是信用分配问题。MADDPG的全局Critic给出的是对联合动作的评价,但没有分解。COMA算法使用反事实基线来解决这个问题,为每个智能体计算一个“如果它采取了默认动作,团队奖励会怎样”的基线,从而更精细地评估其贡献。在需要精细激励的复杂合作任务中,这非常有效。

可扩展性与异构智能体:MADDPG在智能体数量增多时,Critic网络的输入维度会线性增长,导致训练困难。对于大规模智能体群,通常采用均值场方法(将其他所有智能体的影响近似为一个平均场)或者图神经网络(将智能体视为图中的节点,只和相邻节点交互)。另外,现实中的智能体往往是异构的(例如无人机和地面机器人协同),它们的观察空间、动作空间和能力都不同。这要求算法能处理非对称的信息和策略。我参与的一个仓储机器人项目就涉及拣选机器人和搬运机器人,我们为不同类型机器人设计了不同的Actor网络结构,但共享一个基于图神经网络的Critic来进行协同训练。

样本效率与离线学习:和所有深度强化学习算法一样,MADDPG的样本效率仍然较低,需要大量的环境交互。这在物理机器人上是昂贵甚至危险的。离线强化学习技术试图从已有的、可能由不同策略收集的数据集中学习,而不与环境交互。如何将离线学习与多智能体结合是一个热门方向。另一个思路是基于模型的强化学习,让智能体学会一个环境动力学模型,然后在模型里进行“想象”和规划,减少真实交互。

从我个人的经验来看,多智能体强化学习正从实验室的仿真环境快速走向真实的复杂系统。其核心魅力在于它模拟了真实世界中“系统”的涌现行为——简单的个体规则,通过交互产生复杂的群体智能。虽然前路还有稳定性、可解释性、通信约束等诸多挑战,但每一次算法的演进,都让我们离打造出真正能协作、能竞争的AI群体更近了一步。如果你对某个具体方向,比如如何将MADDPG部署到真正的机器人车队上,或者如何设计更高效的通信协议感兴趣,我们可以再找机会深入聊聊。

多智能体强化学习之MADDPG MADDPG(Multi-agent Deep Deterministic Policy Gradient) MADDPG可以看作三部分,首先是DPG(Deterministic Policy Gradient),然后是DDPG(Deep Deterministic Policy Gradient),最后是MADDPG(Multi-agent Deeep Deterministic Policy Gradient)。我们需要逐一了解。 1、什么是DPG? DPG是在连续动作空间上采用确定策略进行Policy 阅读详情

相关推荐

从代码到论文理解并复现MADDPG算法(基于飞桨的强化学习套件PARL)

MADDPG算法是强化学习的进阶算法,在读对应论文Multi-Agent Actor-Critic for Mixed Cooperative-Competitive Environments的过程中,往往会遇到很多不是很好理解的数学公式,这篇文章旨在帮助读者翻过数学这座大山,从PARL的代码理解MADDPG算法。 把MADDPG拆分成多个算法 什么是多智能体?有哪些环境? 从PARL的代码解读MADDPG 复现“老鹰捉小鸡”的游戏环境 回归论文 1. 把MADDPG拆分成多个算法MADDPG的全称是

zbp_12138的博客 3万+

多智能体深度强化学习——MADDPG算法代码分析(tensorflow)

MADDPG算法介绍 MADDPG代码分析与实验

One step, One punch 4万+

多智能体连续行为空间问题求解——MADDPG

目录1. 问题出现:连续行为空间出现2. DDPG 算法2.1 DDPG 算法原理2.2 DDPG 算法实现代码 MADDPG 是一种针对多智能体、连续行为空间设计的算法。MADDPG 的前身是DDPG,DDPG 算法旨在解决连续性行为空间的强化学习问题,而 MADDPG 是在 DDPG 的基础上做了改进,使其能够适用于多智能体之间的合作任务学习。本文先从 DDPG 引入,接着再介绍如何在 DDPG 算法上进行修改使其变成 MADDPG 算法。 1. 问题出现:连续行为空间出现 Q-Learning 算

qq_38638132的博客 7526

多智能体深度确定性策略梯度(MADDPG)算法介绍及代码实现

多智能体深度确定性策略梯度(Multi-Agent Deep Deterministic Policy Gradient, MADDPG)算法是一种在多智能体环境中使用的强化学习算法。这种算法是基于深度确定性策略梯度(DDPG)算法的扩展。MADDPG主要用于解决多智能体环境中的协作和竞争问题,特别是在智能体之间的交互可能非常复杂的情况下。下面将详细介绍MADDPG算法的核心概念和工作原理。

QHCV的博客 3万+

多智能体深度强化学习 # MADDPG

前置基础: DDPG 多智能体深度强化学习 # 多智能体深度强化学习基础 Multi-Agent:多智能体 Deep:与DQN类似,使用目标网络+经验回放 Deterministic:直接输出确定性的动作 Policy Gradient: 基于策略Policy来做梯度下降从而优化模型 MADDPG其实是在DDPG的基础上做的修改,而DDPG可以看作在DPG的基础之上修改而来,DPG是确定性输出的Policy Gradient;也可以把DDPG理解为让DQN可以扩展到连续控制动作空间的算法。 DDPG不适

skysys的研究小屋 7576

多智能体强化学习-MADDPG

【多智能体强化学习】MADDPG:Multi-Agent Actor-Critic for Mixed Cooperative-Competitive Environments.

大鱼治不了水的博客 4282

多智能体强化学习算法MADDPG(一:由单智能体强化学习到多智能体强化学习)

我,菜拐拐,今天又来了!废话少说,上重点。准备好课堂笔记┗|`O′|┛ 嗷~~ 多智能体强化学习背景知识为什么提出多智能体DDPG(MADDPG)?学习MADDPG算法的先验知识?Q-LearningDQNSPGDPGDDPG由DDPG算法到MADDPG算法?MADDPG算法的巧妙之处? 为什么提出多智能体DDPG(MADDPG)? 多智能体环境下传统算法的短板 传统的Q-Learning算法不适用:随着训练的进行,每个智能体的策略都在发生变化。从任何一个单独的智能体的角度来看,环境都变得不稳定,这带来.

qq_40089637的博客 1万+

深度强化学习笔记——DDPG原理及实现(pytorch)

概要 DDPG算法原理(Deep Deterministic Policy Gradient) DDPG算法实现

One step, One punch 2万+

【MADRL】多智能体深度确定性策略梯度(MADDPG )算法

MADDPG (Multi-Agent Deep Deterministic Policy Gradient) 是一种用于多智能体强化学习环境的算法。它由2017年发布的论文《Multi-Agent Actor-Critic for Mixed Cooperative-Competitive Environments》提出。MADDPG结合了深度确定性策略梯度(DDPG)算法的思想,并对多智能体场景进行了扩展,能够处理混合的协作与竞争环境。

博主关注人工智能、强化学习、嵌入式等||985高校A+学科研究生、猿龄六年||优快云博客专家、2024年博客之星TOP33、华为云享专家、人工智能领域优质创作者。 1万+

RL策略梯度方法之(九):Multi-agent DDPG (MADDPG)

本专栏按照 https://lilianweng.github.io/lil-log/2018/04/08/policy-gradient-algorithms.html 顺序进行总结 。 文章目录原理解析算法实现总体流程代码实现 原理解析 算法实现 总体流程 代码实现

qq_38293297的博客 4102

论文阅读-基于深度强化学习的方法解决多智能体防御和攻击问题

本文从深度确定性策略梯度( DDPG )算法出发,引入多智能体深度确定性策略梯度( MADDPG )算法来解决不同情况下的多智能体防御和攻击问题。我们重新构建所考虑的环境,重新定义连续状态空间,连续动作空间和奖励函数,然后应用深度强化学习算法来获得有效的决策策略。为了验证基于DRL的方法的可行性和有效性,进行了多个考虑不同对抗场景的实验。实验结果表明,通过学习智能体可以做出更好的决策,并且使用MADDPG进行学习比使用其他基于DRL的模型取得了更优越的性能,这也说明了掌握其他智能体信息的重要性和必要性。

aaaccc444的博客 3050

从DDPG到MADDPG:图解多智能体强化学习的进化之路(含PyTorch对比实验)

本文深入解析了从DDPG到MADDPG的多智能体强化学习进化路径。针对多智能体环境中的非平稳性难题,MADDPG创新性地采用“集中训练、分散执行”的Actor-Critic框架,通过全局Critic网络在训练阶段协调智能体,有效解决了传统算法在协作与竞争场景下的学习不稳定问题。文章结合PyTorch代码与可视化对比实验,直观展示了MADDPG在协同导航、捕食者-猎物等任务中的显著性能优势。

moss5的博客 1124

tensorflow2实现多智能体强化学习算法MADDPG

使用tensorflow2实现MADDPG算法,包含讲解

Er_Studying_Bai的博客 2020

【二】MADDPG多智能体算法实现(parl)【追逐游戏复现】

论文全称:Multi-Agent Actor-Critic for Mixed Cooperative-Competitive Environments 论文原文:https://download.youkuaiyun.com/download/sinat_39620217/16203960 论文翻译:https://blog.youkuaiyun.com/qiusuoxiaozi/article/details/79066612 ...

丨汀、的博客 2万+

MADDPG算法详解!可创新改进

MADDPG是一种有效的多智能体强化学习算法,尤其适用于连续动作空间的控制任务。通过引入集中训练和分散执行的策略,它能够处理多智能体之间的互动问题。虽然在一些复杂的任务中,训练可能会面临一定的挑战,但在实际应用中,MADDPG具有很大的潜力,尤其是在自动驾驶、无人机协作等领域。

crasher123的博客 2907

多智能体强化学习算法【二】【MADDPG、QMIX、MAPPO】

一、引言 本章介绍OpenAI 2017发表在NIPS 上的一篇文章,《Multi-Agent Actor-Critic for Mixed Cooperative-Competitive Environments》。主要是将AC算法进行了一系列改进,使其能够适用于传统RL算法无法处理的复杂多智能体场景。 传统RL算法面临的一个主要问题是由于每个智能体都是在不断学习改进其策略,因此从每一个智能体的角度看,环境是一个动态不稳定的,这不符合传统RL收敛条件。并且在一定程度上,无法通过仅仅改变智能体自身的策略

丨汀、的博客 5127
上一篇: RStudio Server Configuration: Troubleshooting Common Installation and Runtime Issues
下一篇: 解码PCIe错误:从Malformed TLP到Unexpected Completion的故障排查指南
寂静夜空35
博客等级 码龄3年 60粉丝 1797原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值