在这篇文章中，我将集中讨论一个给定一个短数据序列的推断概率的例子。我将首先介绍如何用贝叶斯方法进行期望推理的理论，然后在 Python 中实现该理论，以便我们能够处理这些想法。为了使文章更容易理解，我将只考虑一小组候选概率。我能够最小化推理的数学难度，同时仍然能够得到非常好的结果，包括先验、似然和后验图。
具体来说，我将考虑以下情况：
- 计算机程序输出一个由 1和 0组成的随机字符串。例如，一个示例输出可能是：
- 目标是推断程序用于生成 D 的 0 的概率。我们使用符号 p0 表示 0 的概率。当然这也意味着 1 的概率必须是 p1=1−p0。
- 如上所述，我们只考虑一组候选概率。具体来说，对上面的数据序列使用候选 p0=0.2,0.4,0.6,0.8。我们如何明智地在这些概率中进行选择，以及我们对结果有多大把握？
概率
我的出发点是写出数列的概率，就好像我知道0或1的概率一样。当然，我不知道这些概率——找到这些概率是我们的目标——但这是先验的有用的地方。例如，我们的示例数据系列的概率，不需要具体说明 p0的值，可以写成:
我使用 p1=1−p0 来写出 p0的概率。我还可以以更紧凑的方式写出上述概率：
上面给出的概率的形式称为 伯努利过程 。我也可以用非常通用的方式来写这个概率，而不是具体关于数据系列 D 或概率 p0，如：
n0 和 n1 表示数据系列中 0 和 1 的数量。
通过替换相关的计数和概率，我可以将一般形式与特定示例联系起来。我首先计算上面给出的数据系列和概率的似然值：
检查结果，我发现 p0 = 0.6的可能性最大，略高于 p0 = 0.8。这里有几点需要注意:
- 我有最大似然值（在考虑的值中）。我可以提供答案 p0=0.6 并完成。
- 概率（似然）的总和 不是 1—— 这意味着我没有正确归一化关于 p0的概率质量函数(pmf) ，我试图推断的参数。贝叶斯推理的一个目标是为 p0 提供一个适当归一化的 pmf，称为后验。
进行上述计算的能力使我能够很好地应用贝叶斯定理并获得所需的后验 pmf。在继续讨论贝叶斯定理之前，我想再次强调似然函数的一般形式 ：
写下对数似然也很有用：
因为当我在下面创建一些 Python 代码时，这种形式增加了数值稳定性。需要明确的是，我使用的是自然（以 e 为底）对数，即 loge(x)=ln(x)。
先验
我已经决定了部分先验——选择 p0∈{0.2,0.4,0.6,0.8} 作为我将考虑的一组概率。剩下的就是为每个候选 p0 分配先验概率，这样我就可以从正确归一化的先验 pmf 开始。假设先验相等，这是一种推理:
其中使用 A1表示我所做的假设。以上信息构成了先验的 pmf。
贝叶斯定理和后验
接下来，我使用 上面定义的 似然 和 先验pmf 来推断 p0 的潜在值。也就是说，我将使用贝叶斯定理来计算 给定似然和先验的 后验pmf。后验有形式：
换句话说，这是 给定数据序列 D 和假设 A1的 p0 的概率，我可以使用贝叶斯定理计算后验：
其中先验 P(p0|A1)是红色，似然 P(D|p0) 是黑色，后验 P(p0|D,A1)是蓝色的。
这使我的 p0信息从假设(A1)更新到假设 + 数据(d，A1) :
我可以通过定义边际似然函数来简化贝叶斯定理 ：
我可以将贝叶斯定理写成以下形式：
后验部分应该被看作是一组方程，对应于 p0的每个候选值，就像我们对似然和先验所做的那样。
最后，对于理论，我计算了 p0 的后验 pmf。让我们从计算依据开始（我知道上面的似然和先验的所有值）：
因此，贝叶斯定理中的分母等于 9.57440e-04。现在，完成后验 pmf 计算。
第一，
第二，
第三，
最后，
回顾
在 Python 代码之前，让我们稍微回顾一下结果。使用数据和贝叶斯定理我已经从 先验的 pmf
到 后验pmf
在贝叶斯设置中，这个后验 pmf 是我们推断 p0的答案，反映了我们对给定假设和数据的参数的知识。通常人们想报告一个单一的数字，但这个后验反映了相当多的不确定性。一些选择是:
- 报告 p0的 最大后验值——在本例中为 0.6。
- 报告 后验平均值、 后验中位数 ——使用后验 pmf 进行计算。
- 包括后验方差或置信区间来描述估计中的不确定性。
然而，报告的推论，沟通不确定性是工作的一部分。在实际操作中，后面的图确实有助于完成任务。所以，让我们离开理论，在 Python 中实现这些想法。
用 Python 编写推理代码
首先，代码导入 numpy 和 matplotlib。使用 ggplot 样式来绘图。
- imprt matlli.pplt as plt
- # 使用 mapltlb 样式表
- try:
- pl.stye.use('gglot')
首先，我创建了一个类来处理 似然。该类接收数据序列并提供一个接口，用于计算给定概率 p0的似然。你能够在方法中找到对数似然方程(对于边际情况需要特别注意)。
1. class liihd:
2. def __int__(elf,dat):
3. """二进制数据"""
4. slff._possa(data)
5.
6. def _pss_a(slf,data):
7. tep = [str(x) for x in dta]
8. for s in ['0', '1']:
9. slf.cnts[s] = emp.ount(s)
10.
11. if len(tmp) != sum(ef.conts.valus()):
12. rase Exepon("!")
13.
14. def _prcs_pobites(self, p0):
15. """处理数据."""
16. n0 = slf.couts['0']
17. n1 = slf.conts['1']
18.
19. if p0 != 0 and p0 != 1:
20. # 例子
21. log_dta = n0*np.og(p0) + \
22. n1*np.log(1.-p0)
23. p_daa = np.ep(opr_dta)
24. elif p0 == 0 and n0 != 0:
25. # 如果不是0，p0就不是0
26. lordta= -np.inf
27. prta = np.exp(lor_daa)
28. elif p0 == 0 and n0 == 0:
29. ## 数据与 p0 = 0一致
30. logpr_data = n1*np.log(1.-p0)
31. prdat = np.exp(lor_dta)
32. elif p0 = 1 and n1 != 0:
33. # 如果 n1不是0 p0就不是1
34. loprta = -np.inf
35. paa = np.exp(lgpaa)
36. elif p0 == 1 and n1 == 0:
37. ordta = n0*np.log(p0)
38. prta = np.xp(lgp_dta)
39.
40.
41. def prb(self, p0):
42. """获取数据的概率"""
43. p_at, _ = sef.pcrbbes(p0)
44.
45. retrn prdta
46.
47. def lo_pb(sef, p0):
48. """获取数据对数概率"""
49. _, lp_at = slf.p_plie(p0)
50.
51. reurn lor_ta
接下来我为先验的 pmf创建一个类 。给定 p0 的候选值列表，默认情况下会创建一个均匀先验。如果需要其他，可以传递先验概率来覆盖此默认值。下面我举个例子。
1. class pri or:
2. def __ni__(self, pls, pobs=Nne):
3. """先验
4. 列表: 允许的 p0’列表
5. P_pos: [可选]先验概率
6. """
7. if p_prbs:
8. # 确保先验正态
9. nom = sum(p_pbs.vaes())
10. sel.lopct = {p:np.log(_prbs[p]) - \
11. np.log(nrm) for p in p_lst}
12. else:
13. n = len(p_is)
14. sef.lo_pict = {p:-np.log(n) for p in p_lst}
15.
16. def __iter__(self):
17. rturn ier(sre(slf.lopit))
18.
19. def lgpob(self, p):
20. """获取p 0的对数/先验概率."""
21. if p in sef.ogpdt:
22. return sf.og_ic[p]
23. else:
24. return -np.inf
25.
26. def prob(slf, p):
27. """获取p 0的先验概率."""
28. if p in slf.gt:
29. retun np.ep(sf.o_pt[p])
30. else:
31. reurn 0.0
最后，我为后验构造一个类， 它采用数据和先验类的一个实例构造后验 pmf。plot() 方法提供了一个非常好的推理可视化，包括 先验、 似然 和 后验的图。
请注意，后验的所有计算都是使用对数概率完成的。这对于数值精度来说是绝对必要的，因为概率可能变化很大，可能非常小。
1. class posir:
2. def __it__(slf, da ta, p ior):
3. """数据：作为列表的数据样本
4. """
5. sel.lod = lklio(dta)
6. lf.prr = prir
7. self.possior()
8.
9. def _pocss_ostrior(elf):
10. """使用传递的数据和先验处理后验。"""
11.
12. nuts = {}
13. deniaor = -npnf
14. for p in slf.prir:
15. netor[p] = sef.lieioo.logrob(p) + \
16. slf.riorog_rob(p)
17.
18. if nurts[p] != -np.inf:
19.
20. deoior = nplgxp(eoior,
21. ners[p])
22.
23. # 保存贝叶斯定理中的分母
24. sef.lo_lielod = deoiato
25.
26. # 计算后验
27. slf.ogict = {}
28. for p in slf.pior:
29. elf.lopct[p] = umros[p] - \
30. slf.lmllio
31.
32. def logpob(self, p):
33. """获取通过 p 的对数后验概率"""
34. if p in self.loic:
35. retrn self.ogdt[p]
36. else:
37. retrn -np.inf
38.
39. def prob(self, p):
40. """获取通过的 p 的后验概率"""
41. if p in sl.lo_pdit:
42. rtrn np.exp(sef.lct[p])
43. else:
44. rurn 0.0
45.
46. def plot(slf):
47. """绘制推理结果"""
48.
49. f, ax= plt.sbs3, 1, ise=(8, 6), hae=Tre)
50. # 从先验中获取候选概率
51. x = [p for p in elf.prir]
52.
53. # 绘制先验ob(p) for p in x])
54. ax[0].sem y1,inf='-, meft'', bef = -')
55.
56.
57. # 绘图似然
58. ax[1].stem(x, y, lifm= -',aerf t=ko bafmt=w')
59.
60. # 绘图后验
61. ax[2].tm,y3 if='b-, mmt=bo, sefm-')
例子
让我们测试一下代码。首先，我将复制我们在理论例子中所做的例子，以确保一切正常:
1. #数据
2. data1
3.
4. # 先验
5. A1 = prior([0.2, 0.4, 0.6, 0.8])
6.
7. # 后验
8. pt1 = postior(da1, A1)
9. plot()
请注意后验 pmf 如何很好地表明 p0=0.6 和 p0=0.8 都有很大的概率——这里存在不确定性！这是有道理的，因为我们只有一个长度为 10 的数据系列，而且只有四个候选概率。另外，请注意：
- 先验和后验中所有数字的总和为 1，反映这些是合适的 pmfs。
接下来，让我们考虑设置一个强先验——偏好 p0 的一个值。使用我们的 Python 代码很容易看到这个先验对结果后验的影响：
1.
1. # 先验- 将按类标准化
2. A2
3.
4. # 后验
5. po2 =1. ptror(data, A2)
2. pot()
注意以下几点：
- 后验和似然不再具有相同的形状。
- p0=0.2,0.4 的后验概率相对于它们的先验概率都 下降了， 因为它们对于提供的数据序列的似然性很低。以类似的方式，p0=0.6,0.8 的后验概率相对于它们的先验概率有所 增加。
最后，让我们用更多的候选概率(这里是100)和更长的数据序列来做一个例子。
1. # 设置为0的概率
2. p0 = 0.2
3. # 设置 rng 种子为 4
4. np.andom.ed(4)
5. # 生成据
6. da2= np.roie([0,1], p=[p0, 1.-p0])
7.
8. # 先验
9. A3 = pir(np.aane)
10.
11. # 后验
12. ps3 = porir(daa2, A3)
13. plot()
注意几点：
- 后验有一个很好的光滑的形状-我处理的概率看起来像是一个连续的值。
- 注意这个数据量的似然值(y 轴)很小。
