多智能体强化学习

引言#

在真实世界中，智能体很少独自行动。无论是团队协作（多个机器人共同搬运物体）、市场竞争（自动驾驶车辆在路口博弈）还是混合场景（王者荣耀 5v5 对战），多个智能体的交互构成了更复杂、更真实的决策环境。

多智能体强化学习（Multi-Agent Reinforcement Learning, MARL） 研究如何让多个智能体在共享环境中学习策略，以实现各自或共同的目标。

MARL 的核心挑战：

🌐 非平稳性：其他智能体的策略在变化，环境不再是静态的
🔄 信用分配：团队奖励如何公平地分配给每个成员？
🤝 协调问题：如何学会合作而非各自为政？
⚔️ 对抗学习：如何在竞争中找到均衡策略？

本文将系统介绍 MARL 的核心概念、经典算法（IQL、VDN、QMIX、MADDPG、MAPPO）以及实战应用。

1. MARL 基础理论#

1.1 从单智能体到多智能体#

单智能体 MDP： $\langle \mathcal{S}, \mathcal{A}, P, R, \gamma \rangle$

多智能体 MDP（Stochastic Game）：

\langle N, \mathcal{S}, \{\mathcal{A}^i\}_{i=1}^N, P, \{R^i\}_{i=1}^N, \gamma \rangle

其中：

$N$ ：智能体数量
$\mathcal{A}^i$ ：智能体 $i$ 的动作空间
$R^i$ ：智能体 $i$ 的奖励函数

联合动作： $\mathbf{a} = (a^1, a^2, \ldots, a^N)$

状态转移： $P(s'|s, \mathbf{a})$ 依赖于所有智能体的动作

1.2 MARL 的分类#

按任务类型#

类型	特征	示例
完全合作	所有智能体共享奖励	多机器人协作、StarCraft
完全竞争	零和博弈，一方收益=对方损失	国际象棋、围棋
混合场景	部分合作+部分竞争	王者荣耀（队内合作、队间竞争）

按信息共享#

模式	训练信息	执行信息	代表算法
完全去中心化	局部	局部	IQL
CTDE	全局	局部	VDN, QMIX, MADDPG
中心化	全局	全局	传统规划方法

CTDE（Centralized Training with Decentralized Execution）：

训练阶段：利用全局信息（如其他智能体的动作、全局状态）
执行阶段：每个智能体只能访问局部观测

1.3 核心挑战详解#

挑战 1：非平稳性（Non-stationarity）#

问题：智能体 A 的策略变化会改变智能体 B 的环境动态。

示例：

1
# 智能体 B 的视角
2
状态 s_t: [位置, 速度, ...]
3
动作 a_t: 向右移动
4
奖励 r_t: +10（成功）
5

6
# 但在 t+1000 时刻，智能体 A 改变策略
7
状态 s_{t+1000}: [相同位置, 相同速度, ...]
8
动作 a_{t+1000}: 向右移动
9
奖励 r_{t+1000}: -5（失败，因为 A 的策略变了）

解决方案：

使用对手建模（opponent modeling）
经验回放时采样多样化策略
Meta-learning 快速适应

挑战 2：维度灾难#

联合动作空间： $|\mathcal{A}^{\text{joint}}| = \prod_{i=1}^N |\mathcal{A}^i|$

示例：5 个智能体，每个有 10 个动作 → $10^5 = 100,000$ 种联合动作

解决方案：

值函数分解（Value Decomposition）
Mean Field 近似
通信机制减少协调复杂度

挑战 3：信用分配（Credit Assignment）#

问题：团队获得 +100 奖励，但智能体 A 出力 80%，智能体 B 只出力 20%，如何公平分配？

解决方案：

差分奖励（Difference Rewards）
Shapley 值
可加性值函数分解

2. 独立学习（Independent Learning）#

2.1 IQL（Independent Q-Learning）#

核心思想：每个智能体独立训练，将其他智能体视为环境的一部分。

算法：每个智能体 $i$ 维护自己的 Q 函数 $Q^i(s, a^i)$ ，使用标准 Q-learning 更新：

Q^i(s, a^i) \leftarrow Q^i(s, a^i) + \alpha \left[ r^i + \gamma \max_{a'^i} Q^i(s', a'^i) - Q^i(s, a^i) \right]

优点：

✅ 实现简单
✅ 完全去中心化
✅ 可扩展到大量智能体

缺点：

❌ 忽略智能体间协调
❌ 收敛性无保证（环境非平稳）
❌ 可能陷入次优均衡

2.2 IQL 实现（简化示例）#

1
import gym
2
import numpy as np
3
import torch
4
import torch.nn as nn
5
import torch.optim as optim
6
from collections import deque
7
import random
8

9
class DQN(nn.Module):
10
    def __init__(self, state_dim, action_dim, hidden_dim=128):
11
        super(DQN, self).__init__()
12
        self.net = nn.Sequential(
13
            nn.Linear(state_dim, hidden_dim),
14
            nn.ReLU(),
15
            nn.Linear(hidden_dim, hidden_dim),
16
            nn.ReLU(),
17
            nn.Linear(hidden_dim, action_dim)
18
        )
19

20
    def forward(self, x):
21
        return self.net(x)
22

23
class IQLAgent:
24
    def __init__(self, agent_id, state_dim, action_dim, lr=1e-3, gamma=0.99, epsilon=1.0):
25
        self.agent_id = agent_id
26
        self.gamma = gamma
27
        self.epsilon = epsilon
28
        self.epsilon_min = 0.01
29
        self.epsilon_decay = 0.995
30

31
        self.q_network = DQN(state_dim, action_dim)
32
        self.target_network = DQN(state_dim, action_dim)
33
        self.target_network.load_state_dict(self.q_network.state_dict())
34

35
        self.optimizer = optim.Adam(self.q_network.parameters(), lr=lr)
36
        self.memory = deque(maxlen=10000)
37

38
    def select_action(self, state):
39
        """ε-greedy 策略"""
40
        if random.random() < self.epsilon:
41
            return random.randint(0, self.q_network.net[-1].out_features - 1)
42

43
        with torch.no_grad():
44
            state = torch.FloatTensor(state).unsqueeze(0)
45
            q_values = self.q_network(state)
46
            return q_values.argmax().item()
47

48
    def store_transition(self, state, action, reward, next_state, done):
49
        self.memory.append((state, action, reward, next_state, done))
50

51
    def update(self, batch_size=64):
52
        if len(self.memory) < batch_size:
53
            return
54

55
        # 采样
56
        batch = random.sample(self.memory, batch_size)
57
        states, actions, rewards, next_states, dones = zip(*batch)
58

59
        states = torch.FloatTensor(states)
60
        actions = torch.LongTensor(actions).unsqueeze(1)
61
        rewards = torch.FloatTensor(rewards).unsqueeze(1)
62
        next_states = torch.FloatTensor(next_states)
63
        dones = torch.FloatTensor(dones).unsqueeze(1)
64

65
        # 当前 Q 值
66
        q_values = self.q_network(states).gather(1, actions)
67

68
        # 目标 Q 值
69
        with torch.no_grad():
70
            next_q_values = self.target_network(next_states).max(1, keepdim=True)[0]
71
            target_q_values = rewards + self.gamma * next_q_values * (1 - dones)
72

73
        # 损失
74
        loss = nn.MSELoss()(q_values, target_q_values)
75

76
        # 更新
77
        self.optimizer.zero_grad()
78
        loss.backward()
79
        self.optimizer.step()
80

81
        # 衰减 epsilon
82
        self.epsilon = max(self.epsilon_min, self.epsilon * self.epsilon_decay)
83

84
    def update_target_network(self):
85
        self.target_network.load_state_dict(self.q_network.state_dict())
86

87
# 多智能体环境训练（伪代码）
88
def train_iql(env, n_agents, n_episodes=1000):
89
    state_dim = env.observation_space.shape[0]
90
    action_dim = env.action_space.n
91

92
    agents = [IQLAgent(i, state_dim, action_dim) for i in range(n_agents)]
93

94
    for episode in range(n_episodes):
95
        states = env.reset()  # 返回所有智能体的状态
96
        episode_reward = 0
97

98
        for step in range(500):
99
            # 每个智能体选择动作
100
            actions = [agent.select_action(states[i]) for i, agent in enumerate(agents)]
101

102
            # 执行联合动作
103
            next_states, rewards, dones, _ = env.step(actions)
104

105
            # 存储经验并更新
106
            for i, agent in enumerate(agents):
107
                agent.store_transition(states[i], actions[i], rewards[i], next_states[i], dones[i])
108
                agent.update()
109

110
            episode_reward += sum(rewards)
111
            states = next_states
112

113
            if all(dones):
114
                break
115

116
        # 定期更新目标网络
117
        if episode % 10 == 0:
118
            for agent in agents:
119
                agent.update_target_network()
120

121
        if episode % 100 == 0:
122
            print(f"Episode {episode}, Total Reward: {episode_reward}")

3. 值函数分解方法#

3.1 VDN（Value Decomposition Networks）#

核心思想（Sunehag et al., 2018）：将全局 Q 函数分解为各智能体 Q 函数的加和。

Q_{\text{tot}}(\mathbf{s}, \mathbf{a}) = \sum_{i=1}^N Q^i(o^i, a^i)

其中 $o^i$ 是智能体 $i$ 的局部观测。

满足条件：

\arg\max_{\mathbf{a}} Q_{\text{tot}}(\mathbf{s}, \mathbf{a}) = \begin{pmatrix} \arg\max_{a^1} Q^1(o^1, a^1) \\ \vdots \\ \arg\max_{a^N} Q^N(o^N, a^N) \end{pmatrix}

优点：

✅ 去中心化执行
✅ 保证一致性（全局最优=局部最优）

缺点：

❌ 表达能力受限（只能加和）
❌ 无法表示复杂协调（如互补动作）

3.2 QMIX#

突破（Rashid et al., 2018）：使用单调混合网络（Monotonic Mixing Network）放松加和限制。

分解形式：

Q_{\text{tot}}(\mathbf{s}, \mathbf{a}) = f_{\text{mix}}(Q^1(o^1, a^1), \ldots, Q^N(o^N, a^N); \mathbf{s})

单调性约束：

\frac{\partial Q_{\text{tot}}}{\partial Q^i} \geq 0, \quad \forall i

网络结构：

1
局部 Q 值: [Q^1, Q^2, ..., Q^N]
2
    ↓
3
Mixing Network (输入全局状态 s):
4
    - 超网络生成权重（确保非负）
5
    - 加权求和 + 非线性变换
6
    ↓
7
全局 Q 值: Q_tot

实现要点：

1
class QMixerNetwork(nn.Module):
2
    def __init__(self, n_agents, state_dim, hidden_dim=32):
3
        super(QMixerNetwork, self).__init__()
4

5
        # 超网络：生成第一层权重
6
        self.hyper_w1 = nn.Sequential(
7
            nn.Linear(state_dim, hidden_dim),
8
            nn.ReLU(),
9
            nn.Linear(hidden_dim, n_agents * hidden_dim)
10
        )
11

12
        # 超网络：生成第二层权重
13
        self.hyper_w2 = nn.Sequential(
14
            nn.Linear(state_dim, hidden_dim),
15
            nn.ReLU(),
16
            nn.Linear(hidden_dim, hidden_dim)
17
        )
18

19
        # 偏置项
20
        self.hyper_b1 = nn.Linear(state_dim, hidden_dim)
21
        self.hyper_b2 = nn.Sequential(
22
            nn.Linear(state_dim, hidden_dim),
23
            nn.ReLU(),
24
            nn.Linear(hidden_dim, 1)
25
        )
26

27
        self.n_agents = n_agents
28
        self.hidden_dim = hidden_dim
29

30
    def forward(self, agent_qs, state):
31
        """
32
        agent_qs: [batch, n_agents]
33
        state: [batch, state_dim]
34
        """
35
        batch_size = agent_qs.size(0)
36

37
        # 生成权重（确保非负）
38
        w1 = torch.abs(self.hyper_w1(state))  # [batch, n_agents * hidden_dim]
39
        w1 = w1.view(batch_size, self.n_agents, self.hidden_dim)
40

41
        b1 = self.hyper_b1(state)  # [batch, hidden_dim]
42

43
        # 第一层：加权求和
44
        hidden = torch.bmm(agent_qs.unsqueeze(1), w1).squeeze(1)  # [batch, hidden_dim]
45
        hidden = hidden + b1
46
        hidden = torch.relu(hidden)
47

48
        # 第二层
49
        w2 = torch.abs(self.hyper_w2(state))  # [batch, hidden_dim]
50
        b2 = self.hyper_b2(state)  # [batch, 1]
51

52
        q_tot = torch.sum(hidden * w2, dim=1, keepdim=True) + b2
53

54
        return q_tot
55

56
# QMIX 训练伪代码
57
class QMIXAgent:
58
    def __init__(self, n_agents, state_dim, action_dim):
59
        # 每个智能体的 Q 网络
60
        self.agent_networks = [DQN(state_dim, action_dim) for _ in range(n_agents)]
61

62
        # 混合网络
63
        self.mixer = QMixerNetwork(n_agents, state_dim)
64

65
        # 目标网络
66
        self.target_agent_networks = [DQN(state_dim, action_dim) for _ in range(n_agents)]
67
        self.target_mixer = QMixerNetwork(n_agents, state_dim)
68

69
        self.optimizer = optim.Adam(
70
            list(self.mixer.parameters()) +
71
            [p for net in self.agent_networks for p in net.parameters()]
72
        )
73

74
    def compute_loss(self, batch):
75
        states, actions, rewards, next_states, dones = batch
76

77
        # 当前 Q 值（每个智能体）
78
        agent_qs = []
79
        for i, net in enumerate(self.agent_networks):
80
            q = net(states[:, i]).gather(1, actions[:, i].unsqueeze(1))
81
            agent_qs.append(q)
82
        agent_qs = torch.cat(agent_qs, dim=1)  # [batch, n_agents]
83

84
        # 混合为全局 Q
85
        q_tot = self.mixer(agent_qs, states[:, 0])  # 假设全局状态=第0个智能体状态
86

87
        # 目标 Q 值
88
        with torch.no_grad():
89
            target_agent_qs = []
90
            for i, net in enumerate(self.target_agent_networks):
91
                q = net(next_states[:, i]).max(1, keepdim=True)[0]
92
                target_agent_qs.append(q)
93
            target_agent_qs = torch.cat(target_agent_qs, dim=1)
94

95
            target_q_tot = self.target_mixer(target_agent_qs, next_states[:, 0])
96
            target_q_tot = rewards + self.gamma * target_q_tot * (1 - dones)
97

98
        # 损失
99
        loss = nn.MSELoss()(q_tot, target_q_tot)
100
        return loss

3.3 VDN vs QMIX 对比#

维度	VDN	QMIX
表达能力	线性加和	非线性单调函数
协调能力	弱	强
计算复杂度	低	中
理论保证	简单	单调性保证
适用场景	简单合作	复杂协调

4. 多智能体 Actor-Critic#

4.1 MADDPG（Multi-Agent DDPG）#

核心思想（Lowe et al., 2017）：CTDE 框架下的 Actor-Critic。

关键设计：

训练：Critic 访问所有智能体的动作和状态（中心化）
执行：Actor 只使用自己的观测（去中心化）

Critic 更新（智能体 $i$ ）：

L(\phi^i) = E \left[ \left( Q^i_{\phi^i}(s, a^1, \ldots, a^N) - y^i \right)^2 \right]

其中：

y^i = r^i + \gamma Q^i_{\text{target}}(s', \mu^1_{\theta'}(o^1), \ldots, \mu^N_{\theta'}(o^N))

Actor 更新（智能体 $i$ ）：

\nabla_{\theta^i} J(\theta^i) = E \left[ \nabla_{\theta^i} \mu^i_{\theta^i}(o^i) \nabla_{a^i} Q^i_{\phi^i}(s, a^1, \ldots, a^N) \Big|_{a^i = \mu^i_{\theta^i}(o^i)} \right]

优点：

✅ 适用于连续动作空间
✅ 训练稳定（利用全局信息）
✅ 可以学习竞争策略

缺点：

❌ 需要全局状态（训练时）
❌ 智能体数量多时计算量大

4.2 MAPPO（Multi-Agent PPO）#

最新趋势：将 PPO 扩展到多智能体（Yu et al., 2021）。

核心改进：

使用 centralized value function $V(s)$
每个智能体独立的 Actor
PPO-Clip 保证训练稳定

伪代码：

1
class MAPPOAgent:
2
    def __init__(self, n_agents, state_dim, action_dim):
3
        # 每个智能体的 Actor
4
        self.actors = [PolicyNetwork(state_dim, action_dim) for _ in range(n_agents)]
5

6
        # 中心化 Critic（输入全局状态）
7
        self.critic = ValueNetwork(state_dim * n_agents)
8

9
        self.optimizers_actor = [optim.Adam(actor.parameters()) for actor in self.actors]
10
        self.optimizer_critic = optim.Adam(self.critic.parameters())
11

12
    def update(self, batch):
13
        # 计算 GAE
14
        advantages, returns = self.compute_gae(batch)
15

16
        for epoch in range(self.n_epochs):
17
            for i in range(self.n_agents):
18
                # Actor 更新（PPO-Clip）
19
                new_log_probs, entropy = self.actors[i].evaluate(batch.obs[i], batch.actions[i])
20
                ratio = torch.exp(new_log_probs - batch.old_log_probs[i])
21

22
                surr1 = ratio * advantages[i]
23
                surr2 = torch.clamp(ratio, 1 - self.epsilon, 1 + self.epsilon) * advantages[i]
24
                actor_loss = -torch.min(surr1, surr2).mean() - self.entropy_coef * entropy.mean()
25

26
                self.optimizers_actor[i].zero_grad()
27
                actor_loss.backward()
28
                self.optimizers_actor[i].step()
29

30
            # Critic 更新（所有智能体共享）
31
            global_state = torch.cat([batch.obs[i] for i in range(self.n_agents)], dim=-1)
32
            values = self.critic(global_state)
33
            critic_loss = nn.MSELoss()(values, returns)
34

35
            self.optimizer_critic.zero_grad()
36
            critic_loss.backward()
37
            self.optimizer_critic.step()

5. 通信机制#

5.1 CommNet（Communication Neural Network）#

核心思想：智能体之间通过通信通道共享信息。

架构：

1
时间步 t:
2
1. 每个智能体编码自己的观测 → h^i_t
3
2. 广播通信：c^i_t = Σ_{j≠i} h^j_t / (N-1)
4
3. 整合通信：h'^i_t = f(h^i_t, c^i_t)
5
4. 输出动作：a^i_t = π(h'^i_t)

5.2 QCOMM#

改进：学习何时以及向谁通信。

注意力机制：

\alpha_{ij} = \frac{\exp(e_{ij})}{\sum_{k} \exp(e_{ik})}, \quad e_{ij} = \text{Attention}(h^i, h^j)

c^i = \sum_j \alpha_{ij} h^j

6. 实战案例#

6.1 场景：多机器人协作搬运#

环境：3 个机器人需要协同搬运一个大箱子到目标位置。

状态：每个机器人的位置、箱子位置、目标位置动作：上/下/左/右/抓取/释放奖励：

团队奖励：箱子接近目标 → +1
个体惩罚：碰撞 → -0.1

算法选择：QMIX（需要精细协调）

1
# 使用 PyMARL 框架（伪代码）
2
from pymarl import QMIX
3

4
config = {
5
    'env': 'CooperativeNavigation-v0',
6
    'n_agents': 3,
7
    'algorithm': 'qmix',
8
    'mixer': 'qmix',
9
    'batch_size': 32,
10
    'buffer_size': 5000,
11
    'lr': 0.0005,
12
    'gamma': 0.99,
13
    'epsilon_start': 1.0,
14
    'epsilon_finish': 0.05,
15
    'epsilon_anneal_time': 50000
16
}
17

18
qmix = QMIX(config)
19
qmix.train(n_episodes=10000)

6.2 场景：多人博弈（德州扑克）#

算法选择：MADDPG（混合合作竞争）

关键点：

队友之间共享信息（Critic 访问队友动作）
对手建模（通过观测推断对手策略）

7. 调试与优化技巧#

7.1 可视化智能体策略#

1
import matplotlib.pyplot as plt
2
from matplotlib.animation import FuncAnimation
3

4
def visualize_multiagent_episode(env, agents, n_steps=100):
5
    """可视化多智能体轨迹"""
6
    fig, ax = plt.subplots(figsize=(8, 8))
7

8
    states = env.reset()
9
    trajectories = [[] for _ in range(len(agents))]
10

11
    for step in range(n_steps):
12
        actions = [agent.select_action(states[i]) for i, agent in enumerate(agents)]
13
        next_states, _, dones, _ = env.step(actions)
14

15
        for i in range(len(agents)):
16
            trajectories[i].append(states[i][:2])  # 假设前2维是位置
17

18
        states = next_states
19

20
        if all(dones):
21
            break
22

23
    # 绘制轨迹
24
    for i, traj in enumerate(trajectories):
25
        traj = np.array(traj)
26
        ax.plot(traj[:, 0], traj[:, 1], label=f'Agent {i}', marker='o')
27

28
    ax.legend()
29
    ax.set_title('Multi-Agent Trajectories')
30
    plt.show()

7.2 监控协调指标#

1
def compute_coordination_metrics(agents, batch):
2
    """计算协调程度"""
3
    # 动作多样性（熵）
4
    action_distribution = batch.actions.float().mean(dim=0)
5
    action_entropy = -(action_distribution * torch.log(action_distribution + 1e-8)).sum()
6

7
    # 动作一致性（方差）
8
    action_variance = batch.actions.float().var(dim=0).mean()
9

10
    # Q 值一致性
11
    q_values = [agent.q_network(batch.states).max(1)[0] for agent in agents]
12
    q_variance = torch.stack(q_values).var(dim=0).mean()
13

14
    return {
15
        'action_entropy': action_entropy.item(),
16
        'action_variance': action_variance.item(),
17
        'q_variance': q_variance.item()
18
    }

8. 总结与展望#

8.1 核心要点#

MARL 挑战：非平稳性、维度灾难、信用分配
经典算法：
- IQL：独立学习，简单但次优
- VDN/QMIX：值函数分解，适合合作
- MADDPG：CTDE 框架，连续动作
- MAPPO：当前 SOTA，稳定性强
CTDE 范式：训练中心化、执行去中心化

8.2 前沿方向#

大规模 MARL：处理数百甚至数千智能体
迁移学习：跨任务、跨智能体数量迁移
可解释性：理解协调机制
鲁棒性：应对通信延迟、智能体失效

8.3 实践建议#

🎯 从简单环境开始（如 Particle Envs）
🎯 使用成熟框架（PyMARL、EPyMARL）
🎯 优先尝试 MAPPO（稳定且性能好）
🎯 可视化！可视化！可视化！

参考资源#

框架：
- PyMARL
- EPyMARL
- SMAC（StarCraft 环境）
论文：
- Sunehag et al. (2018): Value-Decomposition Networks For Cooperative MARL (VDN)
- Rashid et al. (2018): QMIX: Monotonic Value Function Factorisation (QMIX)
- Lowe et al. (2017): Multi-Agent Actor-Critic (MADDPG)
- Yu et al. (2021): The Surprising Effectiveness of PPO in Cooperative MARL (MAPPO)
课程：
- UCL Multi-Agent Systems (Hado van Hasselt)
- Stanford CS 330: Deep Multi-Task and Meta Learning

多智能体强化学习是 RL 领域最具挑战也最具应用潜力的方向。从自动驾驶车队到星际争霸 AI，MARL 正在重塑我们对智能协作的理解。掌握本文的核心算法，你将能够设计和训练复杂的多智能体系统！

多智能体强化学习

🌿 什么是数字花园与思想演进？

引言#

1. MARL 基础理论#

1.1 从单智能体到多智能体#

1.2 MARL 的分类#

按任务类型#

按信息共享#

1.3 核心挑战详解#

挑战 1：非平稳性（Non-stationarity）#

挑战 2：维度灾难#

挑战 3：信用分配（Credit Assignment）#

2. 独立学习（Independent Learning）#

2.1 IQL（Independent Q-Learning）#

2.2 IQL 实现（简化示例）#

3. 值函数分解方法#

3.1 VDN（Value Decomposition Networks）#

3.2 QMIX#

3.3 VDN vs QMIX 对比#

4. 多智能体 Actor-Critic#

4.1 MADDPG（Multi-Agent DDPG）#

4.2 MAPPO（Multi-Agent PPO）#

5. 通信机制#

5.1 CommNet（Communication Neural Network）#

5.2 QCOMM#

6. 实战案例#

6.1 场景：多机器人协作搬运#

6.2 场景：多人博弈（德州扑克）#

7. 调试与优化技巧#

7.1 可视化智能体策略#

7.2 监控协调指标#

8. 总结与展望#

8.1 核心要点#

8.2 前沿方向#

8.3 实践建议#

参考资源#

文章概念网络

引用本文

本篇知识星丛与滑动侧栈

Alpha Zero算法实现五子棋

GRPO 怎样比较同题回答：组内优势、零差异与长度权重

PPO 在限制怎样的更新：概率比、裁剪与价值估计

MCTS 树搜索实验

Kuhn Poker CFR 纳什均衡