博弈论Python仿真（一）

      

目录

一、Agenda

二、收益矩阵（Payoff Matrix）

三、纳什均衡（Nash Equilibrium）

四、如何计算混合策略纳什均衡的return 

五、limitations of Nash equilibrium（纳什均衡局限性）

六、练习

 1、“Hawk-Dove” game     

 2、和美女抛硬币

3、智猪博弈

---

        具有竞争或对抗性质的行为称为博弈行为。在这类行为中，参加斗争或竞争的各方各自具有不同的目标或利益。为了达到各自的目标和利益，各方必须考虑对手的各种可能的行动方案，并力图选取对自己最为有利或最为合理的方案。比如日常生活中的下棋，打牌等。博弈论就是研究博弈行为中斗争各方是否存在着最合理的行为方案，以及如何找到这个合理的行为方案的数学理论和方法。维基百科--博弈论

一、Agenda

1、payoff matrix of a game（博弈的收益矩阵）

2、what is a dominant strategy（什么是占优策略）

3、Nash equilibrium（纳什均衡）

4、pure and mixed strategies（纯粹和混合策略）

5、application in Python（Python仿真）

6、limitations of Nash equilibrium（纳什均衡局限）

7、Pareto efficiency（帕累托效率）

8、Prisoner's dilemma game（囚徒困境）

二、收益矩阵（Payoff Matrix）

        假设有两名玩家，player A 和 player B ，每个玩家都有两种策略，player A 可以选择“TOP”或者“Bottom”，player B 可以选择“Left”或者“Right”。做出不同的行为所对应的收获也是不同的。如下表：（红色表示玩家A的回报，蓝色表示玩家B的回报。）

	Player B
Player A		Left	Right
	Top	2, 4	0, 2
	Bottom	4, 2	2, 0

        分析会出现的四种情况：

Case 1：如果玩家A选择TOP，玩家B可以选择Left或者Right，回报分别是4和2，显然，玩家B会选择Left；

Case 2：如果玩家A选择Bottom，玩家B可以选择Left或者Right，回报分别是2和0，显然，玩家B会选择Left；

Case 3：如果玩家B选择Left，玩家A可以选择Top或者Bottom，回报分别是2和4，显然，玩家A会选择Bottom；

Case 4：如果玩家B选择Right，玩家A可以选择Top或者Bottom，回报分别是0和2，显然，玩家A会选择Bottom；

        因此，不管玩家A选择什么，玩家B为了追求最大的回报，总会选择Left；同样，无论玩家B选择什么，玩家A为了追求最大回报，总会选择Bottom。

        所以这里的均衡策略就是Player A选择Bottom，Player B选择Left。

        Dominant strategy（主导策略/占优策略）无论其他玩家采用何种策略，这里都有一个针对每个玩家的最佳策略。

Dominant strategy: There is one optimal strategy for each player irrespective of what strategy the other player adopts. Whatever choice B makes, A should always choose Bottom and whatever choice A makes B should always choose Left.

        在这里，我们可以使用Python进行仿真实验。用到的函数库为 nashpy。代码如下：

import nashpy
import numpy

a = numpy.array([[2, 0],
                 [4, 2]])
b = numpy.array([[4, 2],
                 [2, 0]])
rps = nashpy.Game(a, b)
print(rps)

equilibrium = rps.support_enumeration()
for eq in equilibrium:
    print(eq)

        分别把玩家A和玩家B的收益矩阵存到numpy数组a和b中， 将这两个数组存入到nash.Game这个类中。然后使用support_enumeration()方法。

运行结果：

Bi matrix game with payoff matrices:
Row player:
[[2 0]
 [4 2]]
Column player:
[[4 2]
 [2 0]]
(array([0., 1.]), array([1., 0.]))

 Row Player指的是行玩家的收益矩阵，Column Player指的是列玩家的收益矩阵。

(array([0., 1.]), array([1., 0.]))

返回值可以解释为：Player A有两个策略（TOP，Bottom），Player B有两个策略（Left，Right），Player A选择策略Bottom概率为1，Player B选择策略Left概率为1.可以看到此结果和我们自己枚举的结果是一样的。 

三、纳什均衡（Nash Equilibrium）

        把上表的收益进行修改，变成下表所示：

	Player B
Player A		Left	Right
	Top	4, 2	0, 0
	Bottom	0, 0	2, 4

        分析会出现的四种情况：

Case 1：如果玩家A选择TOP，玩家B可以选择Left或者Right，回报分别是2和0，显然，玩家B会选择Left；

Case 2：如果玩家A选择Bottom，玩家B可以选择Left或者Right，回报分别是0和4，显然，玩家B会选择Right；

Case 3：如果玩家B选择Left，玩家A可以选择Top或者Bottom，回报分别是4和0，显然，玩家A会选择TOP；

Case 4：如果玩家B选择Right，玩家A可以选择Top或者Bottom，回报分别是0和4，显然，玩家A会选择Bottom；

通过枚举可以看出，玩家A的最优决策（optimal choice）取决于玩家B的决策；玩家B的最优决策取决于玩家A的决策。

A pair of strategies is said to be Nash equilibrium (NE), if optimal choice of Player A given Player B’s choice coincides with optimal choice of Player B given Player A’s choice. In simple terms, initially neither player knows what the other player will do when deciding or making a choice. Hence NE is a pair of choices/strategies/expectations where neither player wants to change their behaviour even after the strategy/choice of the other player is revealed.

        在这个博弈中，如果玩家A选择了TOP，那么B就会选择Left；如果玩家A选择了Bottom，那么B就会选择Right；如果玩家B选择了Left，那么A就选择TOP；如果玩家B选择了Right，A就选择Bottom。可以发现，这个博弈存在两个纳什均衡策略。

        同样采用Python进行仿真实验：

import nashpy
import numpy

a = numpy.array([[4, 0],
                 [0, 2]])
b = numpy.array([[2, 0],
                 [0, 4]])
rps = nashpy.Game(a, b)
print(rps)

equilibrium = rps.support_enumeration()
for eq in equilibrium:
    print(eq)

        输入结果：

Bi matrix game with payoff matrices:
Row player:
[[4 0]
 [0 2]]
Column player:
[[2 0]
 [0 4]]
(array([1., 0.]), array([1., 0.]))
(array([0., 1.]), array([0., 1.]))
(array([0.66666667, 0.33333333]), array([0.33333333, 0.66666667]))

输出结果上面7行就不过多解释，这里只解释后面三行。

由题意知：Player A有两个策略（TOP，Bottom），Player B有两个策略（Left，Right）。

(array([1., 0.]), array([1., 0.]))

这句话代表着第一个Nash equilibrium，即玩家A选择TOP，玩家B选择Left； 

(array([0., 1.]), array([0., 1.]))

 这句话代表着第一个Nash equilibrium，即玩家A选择Bottom，玩家B选择Right； 

在试图理解最后一行输出时，先要理解混合策略（mixed strategies）。在上一个仿真实验中，最后的结果称之为纯策略（pure strategies），简单来说就是：不管你怎么着，A就选Bottom，B就选Left，并且永远这样。而混合策略就是玩家可以根据分配的概率选择策略。

(array([0.66666667, 0.33333333]), array([0.33333333, 0.66666667]))

这句话代表着，玩家A选择TOP的概率为66.7%，选择Bottom的概率为33.3%；玩家B选择Left概率为33.3%，选择Right概率为66.7%。因为只有这样，才能最大化回报。

因此，混合策略纳什均衡（mixed strategy Nash equilibrium）可以定义为：

“Each player chooses the optimal “frequency” with which to play his strategies given the frequency choices of the other player”

四、如何计算混合策略纳什均衡的return 

 考虑到玩家A和B：

其中和是A和B的混合策略

然后行玩家A（row player）的效用/回报（utility/pay-off）计算公式是：

 列玩家（column player ）B的效用/回报（utility/pay-off）计算公式是：

 A 和 B给定概率：

A 和 B回报：

 根据上面的公式，我们可以计算A和B分别的收益率：

A：0.67*0.33*4 +0.33*0.67*0+0.33*0.67*0+0.33*0.67*2 = 1.3266

B：0.33*0.67*2 + 0.67*0.33*0 + 0.33*0.67*0+0.67*0.33*4 = 1.3266

        使用Python进行仿真实验：

import nashpy
import numpy

a = numpy.array([[4, 0],
                 [0, 2]])
b = numpy.array([[2, 0],
                 [0, 4]])

sigma_row = numpy.array([.67, .33])
sigma_column = numpy.array([0.33, 0.67])

rps = nashpy.Game(a, b)
print(rps[sigma_row, sigma_column])

        输入结果：

[1.3266 1.3266]

可以看出，和我们手动计算的结果一样。

五、limitations of Nash equilibrium（纳什均衡局限性）

1、Multiple Nash equilibria

        如第二个表格，存在两个纳什均衡，在这种情况下，没有唯一确定的解决方案。

2、No Nash equilibrium

        看下表：

	Player B
Player A		Left	Right
	Top	0, 0	0, -2
	Bottom	2, 0	-2, 6

        分析会出现的四种情况：

Case 1：如果玩家A选择TOP，玩家B可以选择Left或者Right，回报分别是0和-2，显然，玩家B会选择Left；

Case 2：如果玩家A选择Bottom，玩家B可以选择Left或者Right，回报分别是0和6，显然，玩家B会选择Right；

Case 3：如果玩家B选择Left，玩家A可以选择Top或者Bottom，回报分别是0和2，显然，玩家A会选择Bottom；

Case 4：如果玩家B选择Right，玩家A可以选择Top或者Bottom，回报分别是0和-2，显然，玩家A会选择TOP；

可以看出，在该博弈中，不存在纳什均衡。

        使用Python仿真实验：

import nashpy
import numpy

a = numpy.array([[0, 0],
                 [2, -2]])
b = numpy.array([[0, -2],
                 [0, 6]])
rps = nashpy.Game(a, b)
print(rps)

equilibrium = rps.support_enumeration()
for eq in equilibrium:
    print(eq)

sigma_row = numpy.array([.75, .25])
sigma_column = numpy.array([0.5, 0.5])

print(rps[sigma_row, sigma_column])

        得到结果：

Bi matrix game with payoff matrices:
Row player:
[[ 0  0]
 [ 2 -2]]
Column player:
[[ 0 -2]
 [ 0  6]]
(array([0.75, 0.25]), array([0.5, 0.5]))
[0. 0.]

 同样，前7行不解释，但是发现和前面几个仿真相比，缺少了(array([1., 0.]), array([1., 0.]))，这说明不存在纳什均衡。

(array([0.75, 0.25]), array([0.5, 0.5]))

这句话代表A或者B想要获得最大的收益，选取那个策略的概率。

[0. 0.]

 这句话代表着，根据上面的概率，A和B的预期收益是0和0.（可以手动验算）

3、Nash equilibrium does not ensure Pareto efficient outcomes 

先说明什么是Pareto efficiency（帕累托效率）：

帕累托效率是一种情况，在这种情况下，没有一个人能够在不使至少一个人的境况恶化的情况下变得更好。也就是帕累托最优（Pareto Optimality），帕累托最优状态就是不可能再有更多的帕累托改进的余地；换句话说，帕累托改进是达到帕累托最优的路径和方法。再换句话说，如果一个人可以在不损害他人利益的同时能改善自己的处境，他就在资源配置方面实现了帕累托最优。

Pareto efficiency is a situation where no individual can be better off without making at least one individual worse-off.

        通过“囚徒困境”这个经典案例，来说明纳什均衡并不能保证Pareto efficient有效。 

（假设你已经看到维基百科的解释，已经了解什么事囚徒困境，这里我们直接列出矩阵）

	Prisoner B
Prisoner A		Confess	Deny
	Confess	-3, -3	0, -6
	Deny	-6, 0	-1, -1

        手动分析会出现的情况（A和B分开审问，双方无法串供）：每个囚犯都有两种策略，分别是“Confess to the crime ”和“Denial of being involved”。

Case 1：如果囚犯A认罪，囚犯B认罪，那么他们两个都面临3年牢狱之灾；

Case 2：如果囚犯A认罪，囚犯B不认罪，那么A直接出狱，B面临6年牢狱之灾；

Case 3：如果囚犯A不认罪，囚犯B认罪，那么B直接出狱，A面临6年牢狱之灾；

Case 4：如果囚犯A不认罪，囚犯B不认罪，那么A和B都各被判一年。

        那么我们在手动分析一下A和B心里是怎么想的（A和B都非常狡猾，互相不信任）：

A：如果对方认罪了，我要是不认罪，我被关6年；如果对方不认罪，我认罪，我直接出狱。所以我认罪！

B：如果对方认罪了，我要是不认罪，我被关6年；如果对方不认罪，我认罪，我直接出狱。所以我认罪！

通过分析，他们两个都会选择认罪。这也就达到了纳什均衡。

        通过Python仿真实验：

import nashpy
import numpy

a = numpy.array([[-3, 0],
                 [-6, -1]])
b = numpy.array([[-3, -6],
                 [0, -1]])
rps = nashpy.Game(a, b)
print(rps)

equilibrium = rps.support_enumeration()
for eq in equilibrium:
    print(eq)

        输出结果：

Bi matrix game with payoff matrices:
Row player:
[[-3  0]
 [-6 -1]]
Column player:
[[-3 -6]
 [ 0 -1]]
(array([1., 0.]), array([1., 0.]))

通过仿真可以发现和我们手动枚举的结果是一样的。 

        虽然此时达到了纳什均衡，但显然这不是最优的策略。我们可以直观看到，两个囚犯只需要同时不认罪，每个人仅面临一年的牢狱之灾，显然这才是最优的。

        通过这个例子，我们可以直观的看出，纳什均衡并不能保证Pareto efficient有效。

六、练习

 1、“Hawk-Dove” game     

         Here is another famous game “Hawk-Dove” game. True to its name “hawk” refers to an aggressive strategy and “dove” to a passive one.

	Player B
Player A		Hawk	Dove
	Hawk	-4, -4	8, 0
	Dove	0, 8	4, 4

        Python：

import nashpy
import numpy

a = numpy.array([[-4, 8],
                 [0, 4]])
b = numpy.array([[-4, 0],
                 [8, 4]])
rps = nashpy.Game(a, b)
print(rps)

equilibrium = rps.support_enumeration()
for eq in equilibrium:
    print(eq)

sigma_row = numpy.array([0.5, 0.5])
sigma_column = numpy.array([0.5, 0.5])

print(rps[sigma_row, sigma_column])

        Return:

Bi matrix game with payoff matrices:
Row player:
[[-4  8]
 [ 0  4]]
Column player:
[[-4  0]
 [ 8  4]]
(array([1., 0.]), array([0., 1.]))
(array([0., 1.]), array([1., 0.]))
(array([0.5, 0.5]), array([0.5, 0.5]))
[2. 2.]

 2、和美女抛硬币

        假如你和一个美女一起玩个数学游戏。美女提议：让我们各自亮出硬币的一面，如果我们都是正面，那么我给你3元；如果我们都是反面，我给你1元；剩下的情况你给我2元。那么你该不该和这位美女玩这个游戏呢？

收益矩阵：

	Beautiful girl
You		正	反
	正	3, -3	-2, 2
	反	-2, 2	1, -1

        Python:

import nashpy
import numpy

a = numpy.array([[3, -2],
                 [-2, 1]])
b = numpy.array([[-3, 2],
                 [2, -1]])
rps = nashpy.Game(a, b)
print(rps)

equilibrium = rps.support_enumeration()
for eq in equilibrium:
    print(eq)

sigma_row = numpy.array([0.375, 0.625])
sigma_column = numpy.array([0.375, 0.625])

print(rps[sigma_row, sigma_column])

        Return:

Zero sum game with payoff matrices:
Row player:
[[ 3 -2]
 [-2  1]]
Column player:
[[-3  2]
 [ 2 -1]]
(array([0.375, 0.625]), array([0.375, 0.625]))
[-0.125  0.125]

        可以看出，如果美女采用0.375概率出正面，0.628概率出反面（只要每8次游戏中出3次正面和5次反面就能受益，至少1/8元），无论你采取什么方案，随便你怎么扔硬币，都是会输。所以不应该和美女玩游戏（玩的好话，8次才花0.125元，但是能和美女玩游戏，想想都值得，哈哈）。

3、智猪博弈

        有两头非常聪明的猪（要不怎么叫智猪呢），一大一小共同生活在一个猪圈里。猪圈的一端有一个踏板，踏板连着开放饲料的机关。只要踏一下，在猪圈的另一端就会出现10个单位食物。经过精确的衡量，任何一头猪去踏这个踏板都会付出相当于两个单位食物的成本；每只猪都可以选择“踏”或者“不踏”踏板。

给出下面四个方案：
1、两只猪一起去踏，然后一起回槽边进食，则大猪由于吃的更快可吃下8个单位食物，小猪只能吃到２个单位食物，扣除各自的成本，大猪实际赢利6个单位食物，小猪则赢利0个单位食物；
2、若大猪去踏，小猪先等候在是食槽边，则大猪因时间耽搁只食得6个单位食物，小猪食得4个单位食物，大猪扣除成本后赢利4单位食物，小猪没有成本因而赢利也为4单位食物；
3、若小猪去踏，大猪先候在槽边，则当小猪赶到槽边时大猪已经吃光了10个单位食物，小猪不仅什么都没吃到，反而付出了2个单位成本；
4、两只猪都不去踏，则大家都只能赢利0

收益矩阵：

	小猪
大猪		踩	不踩
	踩	6, 0	4, 4
	不踩	10, -2	0, 0

        Python：

import nashpy
import numpy

a = numpy.array([[6, 4],
                 [10, 0]])
b = numpy.array([[0, 4],
                 [-2, 0]])
rps = nashpy.Game(a, b)
print(rps)

equilibrium = rps.support_enumeration()
for eq in equilibrium:
    print(eq)

sigma_row = numpy.array([1, 0])
sigma_column = numpy.array([0, 1])

print(rps[sigma_row, sigma_column])

        Return:

Bi matrix game with payoff matrices:
Row player:
[[ 6  4]
 [10  0]]
Column player:
[[ 0  4]
 [-2  0]]
(array([1., 0.]), array([0., 1.]))
[4 4]

 可以看出，无论大猪踩不踩，小猪都不会去踩，大不了大家都没得吃；所以大猪为了能吃上点，只能去踩，有吃的总比没有好吧。