机器博弈 (三) 虚拟遗憾最小化算法

虚拟遗憾最小化算法(Counterfactual Regret Minimization)

  • 如果不能遍历计算机所有节点的遗憾值,那么可以采用虚拟遗憾最小化算法来进行模拟计算。

  • 假设:

    • 集合 A A A是博弈中所有玩家所能采用的行为集(如在石头-剪刀-布游戏中出石头、出剪刀或出布三种行为)
    • I I I为信息集,包含了博弈的规则以及玩家采取的历史行动,在信息集 I I I下所能采取的行为集合记为 A ( I ) A(I) A(I)
  • 玩家 i i i在第 t t t轮次采取的行动 a i ∈ A ( I i ) a_{i} \in A(I_{i}) aiA(Ii)反映了其在该轮次所采取的策略 σ i t \sigma_{i}^{t} σit。包含玩家 i i i在内的所有玩家在 t t t轮次采取的行动 a ∈ A ( I ) a \in A(I) aA(I)构成了一组策略组合 σ t \sigma^{t} σt

  • 在信息集 I I I下采取行动 a a a所反映的策略记为 σ I → a \sigma_{I \rightarrow a} σIa

  • 在第 t t t轮次所有玩家采取的行动是一条序列,记为 h h h。采取某个策略 σ \sigma σ计算行动序列 h h h出现的概率记为 π σ ( h ) \pi^{\sigma}(h) πσ(h)

  • 每个信息集 I I I发生的概率 π σ ( I ) = ∑ h ∈ I π σ ( h ) \pi^{\sigma}(I)=\sum_{h \in I}\pi^{\sigma}(h) πσ(I)=hIπσ(h),表示所有能够到达该信息集的行动序列的概率累加

  • 给定博弈的终结局势 z ∈ Z z \in Z zZ,玩家 i i i在游戏结束后的收益记做 u i ( z ) u_{i}(z) ui(z)

  • 在策略组合 σ \sigma σ下,施加博弈行动序列 h h h后达到最终局势 z z z的概率为 π σ ( h , z ) \pi^{\sigma}(h,z) πσ(h,z)

  有了这些定义之后,我们现在来计算虚拟遗憾:

  • 当采取策略 σ \sigma σ时,其所对应的行动序列 h h h的虚拟价值(Counterfactual Value)如下计算(注:行动序列 h h h未能使博弈进入终结局势):

v i ( σ , h ) = ∑ z ∈ Z π − i σ ( h ) π σ ( h , z ) u i ( z ) v_{i}(\sigma,h)=\sum_{z \in Z} \pi_{-i}^{\sigma}(h)\pi^{\sigma}(h,z)u_{i}(z) vi(σ,h)=zZπiσ(h)πσ(h,z)ui(z)

  我们首先去计算其他玩家在产生行动序列 h h h中他们的概率值是多少,乘以在这个策略下,从行动序列 h h h进入到终止局势 z z z的概率,最终再乘以玩家 i i i在终止局势 z z z的概率。之后对终止局势做一个遍历,把它的乘积做一个累加。

  • 玩家 i i i采取行动 a a a所得到的虚拟遗憾值:

r ( h , a ) = v i ( σ I → a , h ) − v i ( σ , h ) r(h,a)=v_{i}(\sigma_{I \rightarrow a},h) - v_{i}(\sigma,h) r(h,a)=vi(σIa,h)vi(σ,h)

  • 行动序列 h h h所对应的信息集 I I I遗憾值为:

r ( I , a ) = ∑ r ( h , a ) r(I,a)=\sum r(h,a) r(I,a)=r(h,a)

  • 玩家 i i i在第 T T T轮次采取行动 a a a的遗憾值为:

R e g r e t t T ( I , a ) = ∑ t = 1 T r i t ( I , a ) Regret_{t}^{T}(I,a)=\sum_{t=1}^{T}r_{i}^{t}(I,a) RegrettT(I,a)=t=1Trit(I,a)

  • 同样,对于遗憾值为负数的情况,我们不予考虑,记:

R e g r e t i T , + ( I , a ) = m a x ( R i T ( I , a ) , 0 ) Regret_{i}^{T,+}(I,a) = max(R_{i}^{T}(I,a),0) RegretiT,+(I,a)=max(RiT(I,a),0)

  • T + 1 T+1 T+1轮次,玩家 i i i选择行动 a a a的概率计算如下:

σ i T + 1 ( I , a ) = { R e g r e t i T , + ( I , a ) ∑ a ∈ A ( I ) R e g r e t i T , + ( I , a ) i f ∑ a ∈ A ( I ) R e g r e t i T , + ( I , a ) > 0 1 ∣ A ( I ) ∣ o t h e r w i s e \sigma_{i}^{T+1}(I,a) = \left\{\begin{matrix} \frac{Regret_{i}^{T,+}(I,a)}{\sum_{}a \in A(I)Regret_{i}^{T,+}(I,a)}& if \sum_{a \in A(I)}Regret_{i}^{T,+}(I,a)>0\\ \frac{1}{|A(I)|} & otherwise \end{matrix}\right. σiT+1(I,a)={aA(I)RegretiT,+(I,a)RegretiT,+(I,a)A(I)1ifaA(I)RegretiT,+(I,a)>0otherwise

  • 玩家 i i i根据遗憾值大小来选择下一时刻行为,如果遗憾值为负数,则随机挑选一种行为进行博弈。

例子-库恩扑克(Kunh’s pocker)

  • 库恩扑克是最简单的限注扑克游戏,由两名玩家进行游戏博弈,牌值只有1,2和3三种情况。
  • 每轮每位玩家各持一张手牌,根据各自判断来决定加定额赌注。
  • 游戏没有公共牌,摊牌阶段比较未弃牌玩家的底牌大小,底牌牌值最大的玩家即为胜者。
  • 游戏规则:

游戏规则表

库恩扑克(Kunh’s pocker):以先手玩家(定义为玩家 A A A)为例的博弈树:

博弈树

  从初始节点开始,1、2、3分别表示玩家 A A A手中的牌,当玩家拿了1之后,玩家 B B B只能拿2或者3。玩家 A A A选择过牌还是加注,玩家 B B B也可以选择过牌还是加注。依次进行下去,就构建了博弈树。

  • 在这个博弈树里面,总共的信息集与12个:{1,1P,1B,1BP,2,2P,2B,2BP,3,3P,3B,3BP}。
  • 每个信息集由不同路径可以到达。如信息集1PB可通过如下路径到达:

1 玩 家 A 拿 到 大 小 为 1 的 纸 牌 → 1 P 玩 家 A 采 取 过 牌 行 动 → 1 P B 玩 家 B 采 取 加 注 行 动 1_{玩家A拿到大小为1的纸牌}\rightarrow 1P_{玩家A采取过牌行动} \rightarrow 1PB_{玩家B采取加注行动} 1A11PA1PBB

  可见信息集 1 P B 1PB 1PB所对应的行动序列为{P,B}

  • 在该问题中,到达每个信息集的路劲均唯一,因此所有信息集仅对应一个行动序列。

有了上述定义之后,我们可以采取如下算法进行策略选择:

  1. 初始化遗憾值和累加策略表为0
  2. 采用随机选择的方法来决定策略
  3. 利用当前策略与对手进行博弈
  4. 计算每个玩家采取每次行为后的遗憾值
  5. 根据博弈结果计算每个行动的累加遗憾值大小来更新策略
  6. 重复博弈若干次
  7. 根据重复博弈最终的策略,完成最终的动作选择

计算1PB的遗憾值

  • 假设初始情况下,两个玩家都以随机选择的策略进行决策,即在任一节点,都以50%的概率分别选择过牌和加注
  • 若第一轮中,玩家 A A A的博弈过程为 1 → P 1 P → B 1 P B → B Z 2 1 \overset{P}{\rightarrow}1P \overset{B}{\rightarrow}1PB \overset{B}{\rightarrow} Z_{2} 1P1PB1PBBZ2,收益为 u A ( Z 2 ) = − 2 u_{A}(Z_{2})=-2 uA(Z2)=2
  • 计算玩家 A A A针对信息集 { 1 P B } \{1PB\} {1PB}选择“过牌”行动的遗憾值:
    • 在当前策略下,行动序列 h = { P B } h=\{PB\} h={PB}产生的概率:
      π B σ ( h ) = 1 × 0.5 = 0.5 \pi_{B}^{\sigma}(h) = 1 \times 0.5 = 0.5 πBσ(h)=1×0.5=0.5

  由于在 { 1 P B } \{1PB\} {1PB}节点选择加注和过牌的概率均为50%,所以当前策略下,从行动序列 h h h到达终结状态 z 1 z_{1} z1 z 2 z_{2} z2的概率分别为:

π σ ( h , z 1 ) = 0.5 , π σ ( h , z 2 ) = 0.5 \pi^{\sigma}(h,z_{1})=0.5,\pi^{\sigma}(h,z_{2})=0.5 πσ(h,z1)=0.5,πσ(h,z2)=0.5

  又已知 u A ( z 1 ) = − 1 u_{A}(z_{1})=-1 uA(z1)=1 u A ( z 2 ) = − 2 u_{A}(z_{2})=-2 uA(z2)=2,可知当前策略的虚拟价值:

v A ( σ , h ) = π B σ ( h ) × π σ ( h , z 1 ) × u A ( z 1 ) + π B σ ( h ) × π σ ( h , z 2 ) × u A ( z 2 ) = 0.5 × 0.5 × ( − 1 ) + 0.5 × 0.5 × ( − 2 ) = − 0.75 v_{A}(\sigma,h)=\pi_{B}^{\sigma}(h) \times \pi^{\sigma}(h,z_{1}) \times u_{A}(z_{1})+\pi_{B}^{\sigma}(h) \times \pi^{\sigma}(h,z_{2}) \times u_{A}(z_{2}) \\ = 0.5 \times0.5 \times (-1) + 0.5 \times 0.5 \times (-2) = -0.75 vA(σ,h)=πBσ(h)×πσ(h,z1)×uA(z1)+πBσ(h)×πσ(h,z2)×uA(z2)=0.5×0.5×(1)+0.5×0.5×(2)=0.75

  • 若使用过牌策略,即 σ { 1 P B } → P \sigma_{\{1PB\} \rightarrow P} σ{1PB}P,此时玩家 B B B促使行动序列 h = { P , B } h=\{P,B\} h={P,B}达成的概率仍然为 π B σ ( h ) = 0.5 \pi_{B}^{\sigma}(h)=0.5 πBσ(h)=0.5,由于最终抵达的终结状态只有 z 1 z_{1} z1,所以 π σ ( h , z 1 ) = 1 \pi^{\sigma}(h,z_{1})=1 πσ(h,z1)=1
  • 则最终选择过牌的虚拟价值为:

v A ( σ { 1 P B } → P , h ) = π B σ ( h ) × π σ ( h , z 1 ) × u A ( z 1 ) = 0.5 × 1 × ( − 1 ) = − 0.5 v_{A}(\sigma_{\{ 1PB\}\rightarrow P}, h) = \pi_{B}^{\sigma}(h) \times \pi^{\sigma}(h,z_{1}) \times u_{A}(z_{1})=0.5 \times 1 \times (-1) = -0.5 vA(σ{1PB}P,h)=πBσ(h)×πσ(h,z1)×uA(z1)=0.5×1×(1)=0.5

  • 在信息集 { 1 P B } \{1PB\} {1PB}上采取“过牌”的遗憾值

r ( I , P ) = r ( h , P ) = v A ( σ { 1 P B } → P , h ) − v A ( σ , h ) = ( − 0.5 ) − ( − 0.75 ) = 0.25 r(I,P)=r(h,P)=v_{A}(\sigma_{\{1PB\}\rightarrow P},h)-v_{A}(\sigma, h)=(-0.5)-(-0.75)=0.25 r(I,P)=r(h,P)=vA(σ{1PB}P,h)vA(σ,h)=(0.5)(0.75)=0.25

  • 库恩扑克的博弈共有12个信息集,对应上图中的正方形和三角形
  • 通过反复迭代计算,可以得到到达各个信息集应采取行动的概率:

  • 对于玩家 A A A而言,库恩扑克的混合策略纳什均衡的理论解如下( α ∈ [ 0 , 1 / 3 ] \alpha \in [0,1/3] α[0,1/3]):

  可见,算法得到的解与理论得到的解之间较为接近,验证了算法的有效性。

  • 4
    点赞
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
cout << "请输入楼层:"; cin >> floor; cout << "请输入类型:"; cin >> type; cout << "请输入容纳人数:"; cin >> capacity; Dormitory dormitory(dormId, roomId, floor, type好的,这是一个很有挑战性的问题。实现五子棋人机对弈需要使用博弈树搜索, capacity, 0); dormitories.push_back(dormitory); cout << "添加宿舍信息成功!" << endl; 算法,这个算法可以帮助机器找到最优的下棋位置,从而战胜人类玩家 } // 修改宿舍信息 void modifyDormitory() { string dormId; cout << "请输入要。 MATLAB中可以使用递归的方式实现博弈树搜索算法。具体的实现步骤如下: 1. 定义棋盘的大小以及游戏规则(例如:棋子的颜色、下棋顺序、胜修改的宿舍编号:"; cin >> dormId; vector<Dormitory>::iterator iter = find_if(dormitories.begin利条件等)。 2. 创建一个函数,用来计算当前棋盘上某个位置的分数。这个分(), dormitories.end(), [&](const Dormitory& dormitory) { return dormitory.dormId == dormId; }); 数可以根据当前局面的优劣程度来计算,例如:距离已下的棋子越近、连 if (iter == dormitories.end()) { cout << "未找到该宿舍信息!" << endl; } else { 成的棋子数越多等,分数越高。 3. 创建一个递归函数,用来搜索博弈树。 cout << "请输入房间号:"; cin >> iter->roomId; cout << "请输入楼层:"; cin函数需要接受当前局面、当前玩家以及搜索深度等参数。在每一层递归中,函数需要 >> iter->floor; cout << "请输入类型:"; cin >> iter->type; cout << "请输入容纳人遍历当前局面上所有可能的下棋位置,并计算下棋后的局面分数。然后根据玩数:"; cin >> iter->capacity; cout << "修改宿舍信息成功!" << endl; } } 家是人类还是机器,选择最大或最小的分数作为当前局面的分数,并继续 // 删除宿舍信息 void deleteDormitory() { string dormId; cout << "请输入要删除的递归搜索下一层博弈树。最后返回当前局面的分数。 4. 在每一轮人机对宿舍编号:"; cin >> dormId; vector<Dormitory>::iterator iter = find_if(dormitories.begin(), dorm弈中,机器根据当前棋盘状态调用递归函数搜索博弈树,并选择分数最高的下棋itories.end(), [&](const Dormitory& dormitory) { return dormitory.dormId == dormId; }); if (位置。然后更新棋盘状态,并将下棋位置返回给人类玩家。 以上就是实现五子棋人iter == dormitories.end()) { cout << "未找到该宿舍信息!" << endl; } else if (iter机对弈的基本步骤。需要注意的是,博弈树搜索算法的时间复杂度很高,需要->occupancy > 0) { cout << "该宿舍有学生居住,不能删除!" << endl; 优化算法,例如剪枝等技术,才能提高程序的效率。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值