案例：数值模拟 - 三门问题（蒙提霍尔悖论）
sanmen1.png
sanmen2.jpg
sanmen3.gif
三门问题，亦称为蒙提霍尔问题，出自美国的电视游戏节目Let's Make a Deal。问题的名字来自该节目的主持人蒙提·霍尔（Monty Hall）
- 参赛者面前有三扇关闭着的门，其中一扇的后面是一辆汽车，而另外两扇门后面则各藏有一只山羊，选中后面有车的那扇门就可以赢得该汽车
- 当参赛者选定了一扇门，但未去开启它的时候，主持人会开启剩下两扇门中的一扇，露出其中一只山羊。然后问参赛者要不要改变选择，选另一扇仍然关着的门
- 问题：参赛者应不应该改变选择？
1/3，2/3，1/2
所需知识点：
- 生成随机数数组,np.random.randint()
- 布尔索引
- 根据值反查索引,np.where(),np.argmax()
- 自定义运算 apply_along_axis()
- 集合运算，对称差，setxor1d()
- 随机洗牌，np.permutation()
- 随机抽取，np.random.choice()
一种思路：
-
得到三个游戏数据
- ** 生成：三门游戏的数据（见下，二维数组，0/0/1，生成固定数据，再用自定义函数洗牌）
- 生成：用户猜测值
- ** 计算：根据游戏数据得出汽车所在索引值
** 计算：主持人告知一个未猜测的错误值（集合的对称差运算）
** 计算：参赛者改变选择后的猜测值（集合的对称差运算）
计算：参赛者未改变和改变选择后的胜率
游戏数据例子：
[
[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
- 即原先猜中错误项的概率转为猜中正确项的概率
理解方式：信息熵
关键在于主持人指出哪个是汽车，并且告诉你这一行为，给系统增加了新的信息导致整个系统熵减
