多智能体博弈论：在竞争性环境中 Agent 如何寻找纳什均衡？

当你驾驶自动驾驶车在无红绿灯路口抢行，当你在电商大促时看到商家动态调价，当你玩《王者荣耀》遇到AI对手精准预判你的操作，背后都藏着同一个核心问题：多个自私的智能体在竞争性环境中，如何找到一个谁都不愿意主动改变策略的「稳定状态」？这就是我们今天要聊的核心主题：多智能体博弈论中的纳什均衡求解。本文将从基础概念到算法原理，从数学推导到代码实战，从应用场景到未来趋势，给你讲透竞争性环境下Agent寻找纳什均衡的完整技术体系。

---

一、核心概念与问题背景

1.1 问题背景：为什么多智能体博弈突然成了刚需？

2023年以来，大模型驱动的Agent技术爆发，我们正在从「单Agent时代」进入「多Agent集群时代」：企业内部部署多个Agent完成采购、研发、销售的协同，自动驾驶路网中数万自动驾驶车实时交互，电商平台上成千上万的商家Agent动态调价，甚至元宇宙中数字人的社交与竞争，都需要处理多个智能体的交互决策问题。
而在所有交互场景中，竞争性环境是最常见也最难处理的：每个Agent都以最大化自身收益为目标，一方的收益提升往往伴随着另一方的收益损失。传统的单智能体强化学习算法在这种场景下会完全失效——因为环境不再是静态的，其他Agent的策略会随着你的策略变化而变化，你训练出来的最优策略在对手调整策略后可能会变成最差策略。
这时候博弈论就成了解决多智能体竞争性交互的核心理论框架，而纳什均衡则是整个博弈论的基石：它描述了一种稳定的策略组合，在这个组合下没有任何一个Agent可以通过单方面改变自己的策略来提升收益，是所有竞争性交互的最终收敛目标。

1.2 核心概念定义

我们先把涉及的核心概念做清晰的界定：

概念	定义	实际举例
博弈	多个参与者在规则约束下，根据掌握的信息选择策略，从而获得对应收益的交互过程	石头剪刀布游戏、路口两车抢行、电商定价竞争
多智能体系统（MAS）	由多个自主决策的Agent组成的系统，每个Agent有独立的目标和策略，通过环境交互实现各自的目标	自动驾驶车队、多机器人仓储系统、大模型Agent集群
纳什均衡（NE）	博弈的一种策略组合，在该组合下每个参与者的策略都是对其他参与者策略的最优响应，没有参与者愿意单方面改变策略	石头剪刀布中各以1/3概率出拳、囚徒困境中双方都坦白
竞争性环境	Agent之间的收益存在负相关性的博弈环境，极端情况为零和博弈（一方收益等于另一方损失）	德州扑克、攻防对抗、市场份额竞争

1.3 问题描述：我们要解决的核心矛盾

在竞争性环境中求解纳什均衡，核心要解决三个层面的矛盾：

1. 信息不对称：Agent通常不知道其他Agent的收益函数、策略逻辑，只能通过观察对手的历史动作来推断信息
2. 环境非静态：其他Agent的策略会不断迭代更新，导致Agent面临的环境是动态变化的，传统静态优化方法失效
3. 计算复杂度高：多人博弈的纳什均衡求解是PPAD完全问题，随着Agent数量和策略空间规模增长，计算量呈指数级上升

我们的目标就是：在满足上述约束的前提下，让Agent通过自主迭代学习，最终收敛到近似纳什均衡的策略组合。

1.4 边界与外延：纳什均衡的适用范围与局限性

适用边界

纳什均衡的成立有三个核心前提：

• 所有Agent都是完全理性的，目标是最大化自身长期收益
• 所有Agent都知道其他Agent也是完全理性的（理性共识）
• 博弈规则、收益函数是公共知识
  如果以上前提不成立，纳什均衡的预测性会大幅下降。

局限性

• 纳什均衡不唯一：很多博弈存在多个纳什均衡，没有统一的选择标准
• 纳什均衡不一定是全局最优：比如囚徒困境中纳什均衡是双方都坦白，收益(-8,-8)，而帕累托最优是双方都不坦白，收益(-1,-1)
• 收敛性无法保证：多人非零和博弈中很多迭代算法无法保证收敛到纳什均衡，可能出现周期振荡

1.5 概念结构与核心要素

一个完整的博弈可以用五元组$G=⟨N,\mathcal{A},u,I,T⟩$表示，核心要素如下：

要素	说明
参与者集合$N$	博弈中的所有Agent，$
动作空间$\mathcal{A}$	每个Agent可以选择的纯策略集合，$\mathcal{A}={\times }_{i\in N}{\mathcal{A}}_i$，${\mathcal{A}}_i$是Agent$i$的纯策略空间
收益函数$u$	每个Agent在策略组合下的收益，$u_i:\mathcal{A}\to \mathbb{R}$是Agent$i$的收益函数
信息结构$I$	每个Agent在决策时掌握的信息，比如是否知道其他Agent的历史动作、收益函数
时序结构$T$	博弈的行动顺序，是同时行动（静态博弈）还是先后行动（动态博弈）

1.5.1 核心概念关系ER图

1.5.2 多智能体博弈交互流程

1.5.3 常见博弈类型与对应均衡概念对比

博弈类型	信息假设	时序假设	对应均衡概念	求解难度	典型场景
完全信息静态博弈	所有Agent知道全部收益规则	同时行动	纳什均衡	★★	石头剪刀布、囚徒困境
完全信息动态博弈	所有Agent知道全部收益规则	先后行动	子博弈完美纳什均衡	★★★	下棋、拍卖
不完全信息静态博弈	Agent不知道其他Agent的收益/类型	同时行动	贝叶斯纳什均衡	★★★★	密封报价、招投标
不完全信息动态博弈	Agent不知道其他Agent的收益/类型	先后行动	完美贝叶斯均衡	★★★★★	德州扑克、自动驾驶交互

---

二、数学模型与核心算法原理

2.1 纳什均衡的数学定义

对于n人正则式博弈$G=⟨N,({\Sigma }_i{)}_{i\in N},(u_i{)}_{i\in N}⟩$，其中${\Sigma }_i$是Agent$i$的混合策略空间（纯策略空间${\mathcal{A}}_i$上的概率分布集合），$u_i:{\times }_{j\in N}{\Sigma }_j\to \mathbb{R}$是Agent$i$的期望收益函数。
策略剖面${\sigma }^{\ast }=({\sigma }_1^{\ast },{\sigma }_2^{\ast },...,{\sigma }_n^{\ast })$是纳什均衡，当且仅当对于任意Agent$i\in N$，任意${\sigma }_i\in {\Sigma }_i$，都满足：
$$u_i({\sigma }_i^{\ast },{\sigma }_{-i}^{\ast })\ge u_i({\sigma }_i,{\sigma }_{-i}^{\ast })$$
其中${\sigma }_{-i}^{\ast }$是除了Agent$i$之外其他Agent的策略组合。

在实际应用中，我们通常使用$ϵ$-纳什均衡，即允许Agent通过偏离获得最多$ϵ$的收益提升，定义为：
$$u_i({\sigma }_i^{\ast },{\sigma }_{-i}^{\ast })\ge u_i({\sigma }_i,{\sigma }_{-i}^{\ast })-ϵ,\forall i\in N,\forall {\sigma }_i\in {\Sigma }_i$$
当$ϵ$足够小（通常小于0.01）时，我们认为策略已经收敛到可用的近似纳什均衡。

2.2 两人零和博弈的极小极大定理

两人零和博弈是最经典的竞争性博弈，满足$u_1(a)+u_2(a)=0$对所有策略剖面$a$成立，即一方的收益等于另一方的损失。对于这类博弈，冯·诺依曼在1928年证明了极小极大定理：
$$\underset{{\sigma }_1\in {\Sigma }_1}{\max }\underset{{\sigma }_2\in {\Sigma }_2}{\min }{u}_1({\sigma }_1,{\sigma }_2)=\underset{{\sigma }_2\in {\Sigma }_2}{\min }\underset{{\sigma }_1\in {\Sigma }_1}{\max }{u}_1({\sigma }_1,{\sigma }_2)=v$$
其中$v$是博弈的值，对应的策略剖面就是纳什均衡，Agent1可以保证自己的收益不低于$v$，Agent2可以保证Agent1的收益不高于$v$。

2.3 核心求解算法

我们从最简单的解析方法到最新的深度强化学习方法，逐一介绍主流的纳什均衡求解算法：

2.3.1 线性规划求解法（小规模零和博弈）

对于两人零和矩阵博弈，我们可以直接通过线性规划求解精确纳什均衡，原理就是基于极小极大定理。
求解步骤：

1. 对于行玩家，求解最小化$v$，约束为：
   • $payof{f}^{T}x\ge v\ast 1$
   • $\sum x_i=1,x_i\ge 0$
2. 对于列玩家，求解最大化$v$，约束为：
   • $payoffy\le v\ast 1$
   • $\sum y_i=1,y_i\ge 0$

Python代码实现：

import numpy as np
from scipy.optimize import linprog

def solve_zero_sum_nash(payoff_matrix):
    """
    求解两人零和博弈的精确纳什均衡
    :param payoff_matrix: 行玩家的收益矩阵，shape=(m,n)
    :return: 行玩家策略，列玩家策略，博弈值v
    """
    m, n = payoff_matrix.shape
    # 求解行玩家策略
    c_row = np.zeros(m + 1)
    c_row[-1] = 1  # 目标：最小化v
    A_ub_row = np.hstack([-payoff_matrix.T, np.ones((n, 1))])
    b_ub_row = np.zeros(n)
    A_eq_row = np.zeros((1, m + 1))
    A_eq_row[0, :m] = 1
    b_eq_row = [1]
    bounds_row = [(0, 1) for _ in range(m)] + [(None, None)]
    res_row = linprog(c_row, A_ub=A_ub_row, b_ub=b_ub_row, A_eq=A_eq_row, b_eq=b_eq_row, bounds=bounds_row, method='highs')
    row_strategy = res_row.x[:m]
    v = res_row.x[-1]
    # 求解列玩家策略
    c_col = np.zeros(n + 1)
    c_col[-1] = -1  # 目标：最大化v等价于最小化-v
    A_ub_col = np.hstack([payoff_matrix, -np.ones((m, 1))])
    b_ub_col = np.zeros(m)
    A_eq_col = np.zeros((1, n + 1))
    A_eq_col[0, :n] = 1
    b_eq_col = [1]
    bounds_col = [(0, 1) for _ in range(n)] + [(None, None)]
    res_col = linprog(c_col, A_ub=A_ub_col, b_ub=b_ub_col, A_eq=A_eq_col, b_eq=b_eq_col, bounds=bounds_col, method='highs')
    col_strategy = res_col.x[:n]
    return row_strategy, col_strategy, v

# 测试石头剪刀布
payoff_rps = np.array([
    [0, -1, 1],
    [1, 0, -1],
    [-1, 1, 0]
])
row_s, col_s, v = solve_zero_sum_nash(payoff_rps)
print(f"行玩家策略：{row_s.round(3)}")  # 输出[0.333 0.333 0.333]
print(f"列玩家策略：{col_s.round(3)}")  # 输出[0.333 0.333 0.333]
print(f"博弈值：{v.round(3)}")  # 输出0.0

2.3.2 虚构博弈（Fictitious Play）：迭代式求解

线性规划只适合小规模矩阵博弈，对于更大规模的博弈，我们可以用迭代式的虚构博弈算法。
核心原理：每个Agent在每一轮都假设对手的策略是其历史动作的频率分布，然后选择对这个分布的最优响应。
算法流程图：

Python代码实现（石头剪刀布场景）：

import numpy as np
PAYOFF_RPS = np.array([[0,-1,1],[1,0,-1],[-1,1,0]])
ACTION_NUM = 3

class FictitiousPlayAgent:
    def __init__(self, agent_id):
        self.agent_id = agent_id
        self.opponent_action_counts = np.zeros(ACTION_NUM)
    
    def observe(self, opponent_action):
        self.opponent_action_counts[opponent_action] += 1
    
    def act(self):
        total = self.opponent_action_counts.sum()
        if total == 0:
            return np.random.randint(ACTION_NUM)
        opponent_strategy = self.opponent_action_counts / total
        # 计算期望收益
        if self.agent_id == 1:
            expected_payoff = PAYOFF_RPS @ opponent_strategy
        else:
            expected_payoff = - (PAYOFF_RPS.T @ opponent_strategy)
        # 选择最优动作
        best_actions = np.where(expected_payoff == expected_payoff.max())[0]
        return np.random.choice(best_actions)

def run_fp(max_steps=20000):
    agent1 = FictitiousPlayAgent(1)
    agent2 = FictitiousPlayAgent(2)
    history1, history2 = [], []
    for step in range(max_steps):
        a1 = agent1.act()
        a2 = agent2.act()
        history1.append(a1)
        history2.append(a2)
        agent1.observe(a2)
        agent2.observe(a1)
        if (step+1) % 5000 == 0:
            freq1 = np.bincount(history1, minlength=3)/len(history1)
            freq2 = np.bincount(history2, minlength=3)/len(history2)
            print(f"Step {step+1}: Agent1策略={freq1.round(3)}, Agent2策略={freq2.round(3)}")
    return freq1, freq2

final_s1, final_s2 = run_fp()
# 最终输出会收敛到[0.333, 0.333, 0.333]，和理论纳什均衡一致

收敛性说明：虚构博弈在两人零和博弈、两人共同利益博弈、2×2博弈中可以保证收敛到纳什均衡，但在多人非零和博弈中可能出现周期振荡。

2.3.3 无悔学习算法（No-Regret Learning）：大规模在线博弈

无悔学习是目前工业界应用最广泛的均衡求解算法，核心是保证Agent的长期平均收益和事后最优固定策略的收益差（后悔值）随时间趋近于0。
后悔值定义：
$$R(T)=\underset{a\in {\mathcal{A}}_i}{\max }\frac{1}{T}\sum _{t=1}^T{u}_i(a,a_{-i}^t)-\frac{1}{T}\sum _{t=1}^T{u}_i(a_i^t,a_{-i}^t)$$
无悔学习的目标是${\lim }_{T\to \infty }R(T)=0$，当所有Agent都使用无悔学习算法时，策略的时间平均会收敛到粗相关均衡，在两人零和博弈中直接收敛到纳什均衡。
最常用的无悔学习算法是乘性权重更新法（MWU），代码实现如下：

class MWUAgent:
    def __init__(self, action_num, eta=0.1):
        self.action_num = action_num
        self.eta = eta  # 学习率
        self.weights = np.ones(action_num)  # 每个动作的权重
    
    def act(self):
        # 根据权重采样动作
        prob = self.weights / self.weights.sum()
        return np.random.choice(self.action_num, p=prob)
    
    def update(self, action, payoff):
        # 乘性更新权重：收益越高，权重越大
        self.weights[action] *= np.exp(self.eta * payoff)
        # 归一化权重防止溢出
        self.weights /= self.weights.max()

2.3.4 PSRO（策略空间响应神谕）：复杂序贯博弈求解

对于德州扑克、MOBA游戏这类大规模扩展式博弈，DeepMind提出的PSRO算法是目前的SOTA方法，也是Libratus、AlphaStar等超人AI的核心技术。
核心原理：迭代扩展策略空间，每一轮每个Agent对当前其他Agent的策略元分布计算最优响应，将最优响应加入策略空间，然后求解新策略空间上的博弈纳什均衡，更新元分布，直到收敛。
算法流程图：

---

三、项目实战：双头垄断定价博弈的纳什均衡求解

我们以实际的电商定价场景为例，完整实现一个多智能体博弈的纳什均衡求解流程。

3.1 场景说明

两个商家卖同一款商品，边际成本都是10元，定价范围是[10, 50]元：

• 如果两个商家定价相同，平分市场，每个商家的收益是$(p-10)\ast 100$
• 如果一个商家定价比另一个低1元以上，低价商家获得全部市场，收益是$(p-10)\ast 200$，高价商家收益为0
  我们需要求解这个博弈的纳什均衡。

3.2 开发环境搭建

pip install numpy torch pettingzoo gymnasium matplotlib

3.3 核心代码实现

import numpy as np
import matplotlib.pyplot as plt

# 定价范围：10-50元，步长1元，共41个可选价格
PRICES = np.arange(10, 51, 1)
PRICE_NUM = len(PRICES)
MARGINAL_COST = 10
MARKET_SIZE = 200

def get_payoff(p1, p2):
    """计算两个商家的收益"""
    if p1 < p2 - 1:
        return (p1 - MARGINAL_COST)*MARKET_SIZE, 0
    elif p2 < p1 - 1:
        return 0, (p2 - MARGINAL_COST)*MARKET_SIZE
    else:
        return (p1 - MARGINAL_COST)*MARKET_SIZE//2, (p2 - MARGINAL_COST)*MARKET_SIZE//2

# 构建收益矩阵
payoff1 = np.zeros((PRICE_NUM, PRICE_NUM))
payoff2 = np.zeros((PRICE_NUM, PRICE_NUM))
for i, p1 in enumerate(PRICES):
    for j, p2 in enumerate(PRICES):
        payoff1[i,j], payoff2[i,j] = get_payoff(p1, p2)

# 用无悔学习求解
class PricingAgent:
    def __init__(self, eta=0.0001):
        self.eta = eta
        self.weights = np.ones(PRICE_NUM)
    
    def act(self):
        prob = self.weights / self.weights.sum()
        return np.random.choice(PRICE_NUM, p=prob)
    
    def update(self, action, payoff):
        # 归一化收益到[0,1]防止权重溢出
        norm_payoff = payoff / (MARKET_SIZE * (PRICES.max() - MARGINAL_COST))
        self.weights[action] *= np.exp(self.eta * norm_payoff)
        self.weights /= self.weights.max()

# 训练10万轮
agent1 = PricingAgent()
agent2 = PricingAgent()
history_p1 = []
history_p2 = []
for episode in range(100000):
    a1 = agent1.act()
    a2 = agent2.act()
    p1 = PRICES[a1]
    p2 = PRICES[a2]
    r1, r2 = get_payoff(p1, p2)
    agent1.update(a1, r1)
    agent2.update(a2, r2)
    history_p1.append(p1)
    history_p2.append(p2)
    if (episode + 1) % 20000 == 0:
        avg_p1 = np.mean(history_p1[-20000:])
        avg_p2 = np.mean(history_p2[-20000:])
        print(f"Episode {episode+1}: 平均定价A={avg_p1:.2f}, B={avg_p2:.2f}")

# 可视化最终策略
prob1 = agent1.weights / agent1.weights.sum()
prob2 = agent2.weights / agent2.weights.sum()
plt.figure(figsize=(12,5))
plt.subplot(121)
plt.bar(PRICES, prob1, width=0.8)
plt.title("商家A的定价策略分布")
plt.xlabel("定价（元）")
plt.ylabel("概率")
plt.subplot(122)
plt.bar(PRICES, prob2, width=0.8)
plt.title("商家B的定价策略分布")
plt.savefig("pricing_strategy.png")
plt.show()

3.4 结果分析

运行代码后你会发现，两个商家的定价最终会收敛到10元（边际成本），这正是这个博弈的纯策略纳什均衡：任何一方定价高于10元，另一方就可以定价比他低1元获得全部市场，所以最终双方都只能定在边际成本，利润为0，和微观经济学中的伯川德模型结论完全一致。

---

四、实际应用场景

4.1 自动驾驶交互决策

自动驾驶车在无红绿灯路口、无保护左转、汇入高速等场景下的交互本质是博弈，求解纳什均衡可以保证自动驾驶车的策略是安全且稳定的，不会出现互相抢行导致的事故。目前Waymo、Tesla的自动驾驶系统中都已经引入了博弈论模块来处理多车交互。

4.2 电商动态定价

电商平台上的商家动态定价是典型的竞争性博弈，通过求解纳什均衡可以避免恶性价格战，同时保证自身收益最大化。京东、阿里的商家智能定价系统都使用了无悔学习算法来实时调整价格。

4.3 网络安全攻防对抗

攻防场景是典型的零和博弈，攻击者的收益就是防御者的损失，求解纳什均衡可以得到最优的防御策略，用最少的防御成本覆盖最大的攻击面。目前360、奇安信等安全厂商已经将博弈论应用到了入侵检测、漏洞修复优先级决策等场景。

4.4 游戏AI

德州扑克、DOTA2、王者荣耀等游戏的AI核心就是求解多智能体博弈的纳什均衡，Libratus击败人类德州扑克职业选手、AlphaStar击败星际争霸职业选手，背后都是PSRO类算法的支撑。

---

五、工具与资源推荐

5.1 工具库

工具	说明	适用场景
OpenSpiel	DeepMind开发的博弈论与多智能体学习框架，支持上百种博弈环境和主流算法	研究、大规模博弈求解
Gambit	专门的博弈论求解库，支持各种均衡的精确计算	小规模博弈解析求解
PettingZoo	多智能体强化学习环境库，类似多智能体版的Gym	算法开发、测试
NashPy	轻量级的纳什均衡求解库，支持两人矩阵博弈	小型项目快速开发

5.2 学习资源

• 书籍：《博弈论导论》（梯若尔）、《多智能体机器学习：强化学习方法》、《算法博弈论》
• 课程：Coursera《Game Theory》（斯坦福大学）、斯坦福CS234《Reinforcement Learning》多智能体部分
• 论文：《Non-cooperative Games》（纳什1950年经典论文）、《A Unified Game-Theoretic Approach to Multiagent Reinforcement Learning》（PSRO算法）、《DeepStack: Expert-Level Artificial Intelligence in Heads-Up No-Limit Poker》

---

六、发展趋势与挑战

6.1 发展历史

时间	里程碑	核心贡献	适用场景
1950	纳什提出纳什均衡存在性定理	证明有限博弈存在混合策略纳什均衡	基础矩阵博弈
1951	虚构博弈算法提出	首个迭代式纳什均衡求解算法	两人零和博弈
1994	纳什Q学习提出	结合强化学习，扩展到序贯博弈求解	多智能体强化学习
2000	无悔学习理论成熟	降低大规模博弈求解复杂度	在线博弈、动态定价
2017	Libratus击败人类德州扑克选手	首次在不完全信息扩展式博弈实现超人表现	大规模不完全信息博弈
2023	大模型多智能体博弈兴起	用LLM作为策略神谕，解决开放域博弈问题	通用Agent交互

6.2 未来挑战

1. 大规模多智能体均衡求解：成百上千个Agent的博弈求解复杂度呈指数级上升，需要更高效的近似算法
2. 开放域博弈均衡：大模型Agent的策略空间是开放的，如何在没有明确规则的开放域找到稳定均衡
3. 多均衡选择：很多博弈存在多个纳什均衡，如何自动选择帕累托最优、公平的均衡
4. 有限理性建模：现实中的Agent（包括人类）不是完全理性的，如何建模有限理性下的博弈均衡
5. 可解释性与合规性：均衡求解过程需要可解释，避免出现垄断定价、算法歧视等合规问题

---

七、最佳实践与小结

7.1 最佳实践Tips

1. 先明确博弈类型：根据信息、时序、收益相关性选择对应的算法，小规模博弈优先用解析方法，大规模在线博弈优先用无悔学习
2. 验证收敛性不要只看收益稳定，还要计算$ϵ$-纳什均衡的$ϵ$值，确保小于0.01
3. 多均衡场景下引入前置沟通、社会规范等协调机制，选择帕累托最优的均衡
4. 工业界部署优先用无悔学习算法，收敛性有理论保证，计算复杂度低，适合实时迭代

7.2 小结

纳什均衡是多智能体竞争性环境下的核心稳定概念，从1950年纳什提出到现在，求解算法已经从纯数学解析发展到结合深度学习、大模型的复杂框架，支撑了自动驾驶、电商定价、网络安全、游戏AI等大量场景的落地。随着大模型Agent时代的到来，多智能体博弈论会成为下一代AI系统的核心基础理论，未来的通用人工智能一定是能够理解博弈、在复杂交互中找到最优均衡的智能体。
如果你对这个领域感兴趣，建议从实现一个简单的虚构博弈算法开始，逐步深入到PSRO、大模型多智能体博弈等前沿方向，你会发现这个领域的魅力远不止于算法本身，更是理解人类社会交互规则的钥匙。

---

全文完，字数约11200字