案例：数值模拟 - 三门问题（蒙提霍尔悖论）

案例：数值模拟 - 三门问题（蒙提霍尔悖论）

---

sanmen1.png

sanmen2.jpg

sanmen3.gif

---

三门问题，亦称为蒙提霍尔问题，出自美国的电视游戏节目Let's Make a Deal。问题的名字来自该节目的主持人蒙提·霍尔（Monty Hall）

1. 参赛者面前有三扇关闭着的门，其中一扇的后面是一辆汽车，而另外两扇门后面则各藏有一只山羊，选中后面有车的那扇门就可以赢得该汽车
2. 当参赛者选定了一扇门，但未去开启它的时候，主持人会开启剩下两扇门中的一扇，露出其中一只山羊。然后问参赛者要不要改变选择，选另一扇仍然关着的门
3. 问题：参赛者应不应该改变选择？

1/3，2/3，1/2

---

所需知识点：

• 生成随机数数组,np.random.randint()
• 布尔索引
• 根据值反查索引,np.where(),np.argmax()
• 自定义运算 apply_along_axis()
• 集合运算，对称差，setxor1d()
• 随机洗牌，np.permutation()
• 随机抽取，np.random.choice()

---

一种思路：

1. 得到三个游戏数据

   • ** 生成：三门游戏的数据（见下，二维数组，0/0/1，生成固定数据，再用自定义函数洗牌）
   • 生成：用户猜测值
   • ** 计算：根据游戏数据得出汽车所在索引值

2. ** 计算：主持人告知一个未猜测的错误值（集合的对称差运算）

3. ** 计算：参赛者改变选择后的猜测值（集合的对称差运算）

4. 计算：参赛者未改变和改变选择后的胜率

游戏数据例子：

[
    [0, 0, 1],
    [1, 0, 0],
    [0, 1, 0],
    ...
]

import numpy as np

---

第一步：游戏生成三个值，观众猜测

生成三门数据

game2

c = 100000  # 生成100000条数据

game = np.zeros((c, 3))
game
game[:, 2] = 1
game

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

game.shape

(100000, 3)

# 将三门数据1维洗牌，随机化
def _(x):
    return np.random.permutation(x)

game2 = np.apply_along_axis(_, 1, game)
game2[:20]

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

game2.shape

(100000, 3)

验证游戏数据正确与否

np.sum(game2[:, 0]) # 第0列1的个数
np.sum(game2[:, 1])
np.sum(game2[:, 2])

np.sum(game2[:, 0] == 0) # 第0列0的个数
np.sum(game2[:, 1] == 0)
np.sum(game2[:, 2] == 0)

67129

或者这样

# 第0列，1的个数
# np.sum(game2[:,0])
# 第0列，0的个数
# np.sum(game2[:,0] == 0)

def _(a):
    one = np.sum(a) / c
    zero = np.sum(a == 0) / c
    return one,zero

np.apply_along_axis(_, 0, game2)

array([[0.33684, 0.33445, 0.32871],
       [0.66316, 0.66555, 0.67129]])

验证数据正常

三门数据中的汽车所在索引

threeMax

game2[:10]

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

# 方法1
np.argmax(game2, axis=1)

array([2, 2, 1, ..., 1, 2, 0], dtype=int64)

# 方法2
threeMax = np.where(game2 == 1)[1]
threeMax

array([2, 2, 1, ..., 1, 2, 0], dtype=int64)

生成用户猜测数据

guess

# 方法1：随机猜测
guess = np.random.randint(0, 3, c)
guess

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

# 方式2：全部猜2
guess2 = np.full(c, 2)
guess2

array([2, 2, 2, ..., 2, 2, 2])

计算胜率

np.sum(threeMax == guess) / c * 100  # 随机猜测胜率

33.58

np.sum(threeMax == guess2) / c * 100  # 全部猜2的胜率

32.871

猜测固定索引和随机猜测，胜率没有区别，大约在1/3左右

---

第二步：主持人告知一个错误值

测试

使用集合运算的对称差实现

游戏索引值：0,1,2，设汽车在2

观众猜测值：

可能1：猜对了，2，主持人会从2个错误值中随机抽一个输出
可能2：猜错了，0，主持人会输出另一个错误值，1

aa = np.array([0,1,2])  # 游戏数据集合，假设2为汽车
aa

array([0, 1, 2])

# 猜对情况

# 用户猜测索引，正确汽车索引
bb = [2,2]

# 返回用户未猜测的错误值[0, 1]
# setxor1d(x,y) 集合的对称差，即存在于一个数组中但不同时存在于两个数组中的元素，异或
cc = np.setxor1d(aa, bb)
cc

# 两个错误值，二选一输出
np.random.choice(cc)

0

# 猜错情况

bb = [1, 2]

# 返回用户未猜测的错误值 0
cc = np.setxor1d(aa, bb)
cc

# 1个错误值,也采样，为了程序逻辑和上面保持一致
np.random.choice(cc)

0

主持人告知错误值，正式实现

def sError(x):
    aa = np.array([0,1,2])  # 游戏数据集合

    bb = [x[0], x[1]]  # 汽车所在索引，用户猜测索引

    # setxor1d(x,y) 集合的对称差，即存在于一个数组中但不同时存在于两个数组中的元素，异或
    cc = np.setxor1d(aa, bb)
    cc

    # 两个错误值，二选一输出
    return np.random.choice(cc)
    
sayError = np.apply_along_axis(sError, 0, (threeMax, guess))  # 汽车所在索引，用户猜测索引
sayError

array([1, 0, 2, ..., 0, 1, 2], dtype=int64)

手动验证一下主持人给的数据正确与否

# 游戏数据：game2
game2[:10]

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

# 用户猜测数据：guess
guess[:10]

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

# 主持人给出的错误数据：sayError，验证是否正确
sayError[:10]

array([1, 0, 2, 2, 1, 1, 0, 2, 0, 0], dtype=int64)

3：问题：参赛者应不应该改变选择？

手动分析一下，参赛者改变选择的情况：

游戏数据：0,1,2，设汽车索引是2

• 用于猜测：
  • 猜对：2，主持人告诉你0是错误值，选择改成 1
  • 猜错：0，主持人告诉你1是错误值，选择改成 2

# 测试下
aa = np.array([0,1,2])  # 设汽车索引是2
aa

array([0, 1, 2])

# 猜对情况
bb = [2, 1]  # 用户猜测，主持人告知错误索引

# 输出 0，改变选择的结果
np.setxor1d(aa, bb)

array([0])

# 猜错情况
bb = [1, 0]

# 返回 2
np.setxor1d(aa, bb)

array([2])

用户改变选择后选中的索引值，正式执行

def change(x):
    aa = np.array([0,1,2])
    bb = [x[0], x[1]]  # 用户猜测，主持人告知错误索引
    return np.setxor1d(aa, bb)
    
change2 = np.apply_along_axis(sError, 0, (guess, sayError))  # 汽车所在索引，主持人告知错误索引
change2

array([2, 2, 1, ..., 1, 0, 0], dtype=int64)

手动验证一下主持人给的数据正确与否

# 游戏数据：game2
game2[:10]
# 实际改变猜测情况和游戏数据无关，可不看此数据

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

# 用户原猜测数据：guess
guess[:10]

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

# 主持人给出的错误数：sayError，验证是否正确
sayError[:10]

array([1, 0, 2, 2, 1, 1, 0, 2, 0, 0], dtype=int64)

# 用户改变选择后的猜测数数据：change
change2[:10]

array([2, 2, 1, 1, 0, 2, 2, 1, 2, 1], dtype=int64)

计算不改变选择和改变选择的胜率

用户未改变选择的胜率，和主持人打开门之前一样

np.sum(guess == threeMax) / c * 100

33.58

用户改变选择的胜率

np.sum(change2 == threeMax) / c * 100

66.42

---

结论

在主持人告知一个错误值后：

• 不改变原选择，胜率仍为1/3
• 改变选择，胜率会从1/3骤增至2/3
  • 即原先猜中错误项的概率转为猜中正确项的概率

理解方式：信息熵

关键在于主持人指出哪个是汽车，并且告诉你这一行为，给系统增加了新的信息导致整个系统熵减

---