【机器学习】基础之概率论与信息论

该博文的markdown原文链接，猛戳这里！！

引言

概率论是用于表示不确定性声明的框架。它不仅提供了量化不确定性的方法，还提供了用于导出新不确定性声明的公理。

人工智能领域，概率论的用途有两种，首先，概率法则告诉我们AI系统如何推理，据此设计一些算法来计算或者估算由概率论导出的表达式。其次，可以用概率与统计来分析和评价AI系统的行为。

概率论使我们能够提出不确定的声明以及在不确定性存在的情况下进行推理，而信息论则能够使我们量化概率分布中的不确定性总量。

机器学习通常必须处理不确定量，有时可能也要处理随机量。不确定性来自三个方面：被建模系统内在的随机性、不完全观测以及不完全建模。

概率论

概率

• 贝叶斯流派概率：认为概率是对某件事情发生的确定程度，也就是确信的程度；

• 频率流派概率：认为概率就是事情发生的频率。

• 随机变量：随机取不同值的变量，一般用无格式小写字母来表示随机变量，用斜体小写字母表示随机变量能够取到的值。如随机变量$\mathrm{x}$能取到的值有$x_1,x_2$。

  如果随机变量是向量形式，则使用粗体$\mathbf{x}$表示，它的可能取值为$\mathbf{x}$。就其本身而言，一个随机变量只是对可能状态的描述，它必须通过概率分布来指定每个状态的可能性。

  随机变量可能是离散的，也可能是连续的。离散随机变量拥有有限或者可数无限多的状态。状态不一定非要是整数，也可能是一些被命名的状态而没有数值，连续随机变量则是实数值。

概率分布

离散型随机变量和概率质量函数

对于离散型随机变量，其概率分布可用概率质量函数$(\mathrm{p}\mathrm{r}\mathrm{o}\mathrm{b}\mathrm{a}\mathrm{b}\mathrm{i}\mathrm{l}\mathrm{i}\mathrm{t}\mathrm{y}\mathrm{m}\mathrm{a}\mathrm{s}\mathrm{s}\mathrm{f}\mathrm{u}\mathrm{n}\mathrm{c}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n},\mathrm{P}\mathrm{M}\mathrm{F})$来描述，通常用大写字母$P$表示，概率质量函数将每个随机变量能够取得的每个状态映射到随机变量取得该状态时的概率。如随机变量$\mathrm{x}$取$x$时的概率表示为$P(\text{x}=x)$。

一般情况下，随机变量$\mathrm{x}$遵循的概率分布$P(\mathrm{x})$用：$\text{x}\sim P(\text{x})$来表示。概率质量函数$P(\mathrm{x})$必须满足以下条件：

$⧫$$P$的定义域必须是$\text{x}$所有状态的集合；

$⧫$ $\forall x\in \text{x}，0\le P(\text{x})\le 1$;

$⧫$${\sum }_{x\in \text{x}}P(x)=1$.

假设一个随机变量$\text{x}$有$k$个状态，并且遵循均匀分布$(\mathrm{u}\mathrm{n}\mathrm{i}\mathrm{f}\mathrm{o}\mathrm{r}\mathrm{m}\mathrm{d}\mathrm{i}\mathrm{s}\mathrm{t}\mathrm{r}\mathrm{i}\mathrm{b}\mathrm{u}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n})$，通过将它的$\mathrm{P}\mathrm{M}\mathrm{F}$设为
$$P(\text{x}=x_i)=\frac{1}{k}$$
对所有的$i$均成立。

• 联合概率分布

  将概率质量函数同时作用于多个随机变量，如$P(\text{x}=x,\text{y}=y)$，表示$\mathrm{x}=x,\mathrm{y}=y$同时发生的概率。

连续型随机变量和概率密度函数

对于连续型随机变量，其概率分布可用概率密度函数$(\mathrm{p}\mathrm{r}\mathrm{o}\mathrm{b}\mathrm{a}\mathrm{b}\mathrm{i}\mathrm{l}\mathrm{i}\mathrm{t}\mathrm{y}\mathrm{d}\mathrm{e}\mathrm{n}\mathrm{s}\mathrm{i}\mathrm{t}\mathrm{y}\mathrm{f}\mathrm{u}\mathrm{n}\mathrm{c}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n},\mathrm{P}\mathrm{D}\mathrm{F})$描述，通常用小写字母$p$来表示，其必须满足：

$⧫$$P$的定义域必须是$\text{x}$所有状态的集合；

$⧫$ $\forall x\in \text{x}，0\le P(\text{x})$;

$⧫$${\int }_{-\infty }^{\infty }p(x)\mathrm{d}x=1$.

因此可以利用$\mathrm{P}\mathrm{D}\mathrm{F}$求积分来求得点集的真实概率质量。

比如，在$(a,b)$上的均匀分布，
$$U(x;a,b)=\frac{1}{b-a}$$

边缘概率分布

定义：一组变量的联合概率分布中一个子集的概率分布。定义在子集上的概率分布称为边缘概率分布。

假设有离散型随机变量$\text{x, y}$且已知$P(\text{x,y})$。那么
$$\forall x\in \text{x},P(\text{x}=x)=\sum _{y}P(\text{x}=x,\text{y}=y)$$
对连续型变量，则利用积分
$$p(x)=\int p(x,y)dy$$

条件概率分布

定义：某个事件在给定其他事件发生时出现的概率。

比如，在给定$\text{x}=x,$事件$\text{y}=y$发生的概率为
$$P(\text{y}=y\mid \text{x}=x)=\frac{P(\text{y}=y,\text{x}=x)}{P(\text{x}=x)}$$

条件概率的链式法则

任何多维随机变量的联合概率分布都可以分解为只有一个变量的条件概率相乘的形式：
$$P({\text{x}}^{(1)},\cdots ,{\text{x}}^{(n)})=P({\text{x}}^{(1)})\prod _{i=2}^{n}P({\text{x}}^{(i)}\mid {\text{x}}^{(1)},\cdots ,{\text{x}}^{(i-1)})$$
比如，
$$P(a,b,c)=P(a)P(b\mid a)P(c\mid a,b)$$
或者
$$\begin{array}{rl}P(a,b,c)& =P(a\mid b,c)P(b,c)\\ P(b,c)& =P(b\mid c)P(c)\\ P(a,b,c)& =P(a\mid b,c)P(b\mid c)P(c)\end{array}$$

独立性和条件独立性

两个随机变量$\text{x}$和$\text{y}$，若它们的联合概率分布可以表示为单独概率分布的乘积的形式，则称这两个随机变量相互独立，即
$$\forall x\in \text{x},y\in \text{y},P(\text{x}=x,\text{y}=y)=P(\text{x}=x)P(\text{y}=y)$$
如果随机变量$\text{x}$和$\text{y}$的条件概率分布对于随机变量$\text{z}$的每个取值都能写成乘积的形式，那么随机变量$\text{x}$和$\text{y}$在给定随机变量$\text{z}$时是条件独立的，即
$$\forall x\in \text{x},y\in \text{y},z\in \text{z},P(\text{x}=x,\text{y}=y\mid \text{z}=z)=P(\text{x}=x\mid \text{z}=z)P(\text{y}=y\mid \text{z}=z)$$

期望、方差和协方差

期望

期望$(\mathrm{E}\mathrm{x}\mathrm{p}\mathrm{e}\mathrm{c}\mathrm{t}\mathrm{a}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n})$：函数$f$关于概率分布$P(\text{x})$或$P(\text{x})$的期望表示为，由概率分布产生$x$，再将$f$作用在$x$上之后$f(x)$的平均值。即
$${\mathrm{E}}_{x\sim P}[f(x)]=\sum _{x}P(x)f(x)$$
连续型变量则通过积分求得。

方差

方差$(\mathrm{V}\mathrm{a}\mathrm{r}\mathrm{i}\mathrm{a}\mathrm{n}\mathrm{c}\mathrm{e})$：当对$x$依据其概率分布进行采样时，随机变量$x$的函数值$f(x)$会呈现多大的差异。即
$$\mathrm{V}\mathrm{a}\mathrm{r}(f(x))=[(f(x)-\mathrm{E}[f(x)]{)}^2]$$
平方根称为标准差。

协方差

协方差$(\mathrm{C}\mathrm{o}\mathrm{v}\mathrm{a}\mathrm{r}\mathrm{i}\mathrm{a}\mathrm{n}\mathrm{c}\mathrm{e})$：在某种意义上给出了变量之间的线性相关强度以及各个变量的尺度。即
C o v ( f ( x ) , g ( y ) ) = E { ( f ( x ) − E [ f ( x ) ] ) ( g ( y ) − E [ g ( y ) ] ) } \mathrm{Cov}(f(x), g(y)) = \mathbb{E} \{ (f(x) - \mathbb{E}[f(x)]) (g(y) - \mathbb{E}[g(y)]) \} Cov(f(x),g(y))=E{ (f(x)−E[f(x)])(g(y)−E[g(y)])}
协方差的绝对值很大则意味着变量值的变化很大，并且它们距离各自的均值很远。如果协方差是正的，那么两个变量都倾向于同时取得相对较大的值。如果协方差是负的，那么其中一个变量倾向于取得相对较大的值的同时，另一个变量倾向于取得相对较小的值，反之亦然。

相关系数$(\mathrm{c}\mathrm{o}\mathrm{r}\mathrm{r}\mathrm{e}\mathrm{l}\mathrm{a}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n})$将每个变量的贡献归一化，为了只衡量变量的相关性而不受各个变量尺度大小的影响。

• 协方差矩阵

  随机向量$\mathbf{x}\in {\mathbb{R}}^n$的协方差矩阵是一个$n\times n$的矩阵，并且满足
  $$\mathrm{C}\mathrm{o}\mathrm{v}(\mathbf{x}{)}_{i,j}=\mathrm{C}\mathrm{o}\mathrm{v}({\text{x}}_i,{\text{x}}_j)$$
  其中，对角元素是方差。

import numpy as np

x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
y = np.array([8, 7, 6, 5, 4, 3, 2, 1])
Mean = np.mean(x)
Var = np.var(x)
Var_unbias = np.var(x, ddof=1)  # N - ddof
Cov = np.cov(x, y)
print(Mean)  # 4.5
print(Var)  # 5.25
print(Var_unbias)  # 6.0
print(Cov)
# [[ 6. -6.]
#  [-6.  6.]]

常用概率分布

伯努利分布

单个二值随机变量的分布，也叫两点分布。$\varphi$给出了随机变量等于$1$的概率。
$$\begin{gathered} P(\text{x}=1)=\varphi \\ P(\text{x}=0)=1-\varphi \\ P(\text{x}=x)={\varphi }^x(1-\varphi {)}^{(1-x)} \\ {\mathbb{E}}_{\text{x}}[\text{x}]=\varphi \\ {\mathrm{V}\mathrm{a}\mathrm{r}}_{\text{x}}(\text{x})=\varphi (1-\varphi ) \end{gathered}$$

高斯分布

也叫正态分布$(\mathrm{n}\mathrm{o}\mathrm{r}\mathrm{m}\mathrm{a}\mathrm{l}\mathrm{d}\mathrm{i}\mathrm{s}\mathrm{t}\mathrm{r}\mathrm{i}\mathrm{b}\mathrm{u}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n})$。
$$\mathcal{N}(x;\mu ,{\sigma }^2)=\sqrt{\frac{1}{2\pi {\sigma }^2}}{e}^{-\frac{(x-\mu {)}^2}{2{\sigma }^2}}$$
有时也会用$\beta =\frac{1}{{\sigma }^2}$ 表示分布的精度。中心极限定理认为，大量独立的随机变量的和近似于一个正态分布，因此可认为噪声呈正态分布的。

指数分布

$$f(x)=\{\begin{array}{ll}\lambda e^{-\lambda x},& x>0\\ 0,& \text{other.}\end{array}$$

或这样表示
$$p(x;\lambda )=\lambda 1_{x\ge 0}{e}^{-\lambda x}$$
指数分布使用指示函数$1_{x\ge 0}$来使得当$x$取负值的时候概率为$0$。

$\mathrm{L}\mathrm{a}\mathrm{p}\mathrm{l}\mathrm{a}\mathrm{c}\mathrm{e}$分布

允许在任意一点$\mu$处取得峰值。
$$p(x;\gamma ,\mu )=\frac{1}{2\gamma }{e}^{-\frac{|x-\mu |}{\gamma }}$$

常用函数

$\mathrm{s}\mathrm{i}\mathrm{g}\mathrm{m}\mathrm{o}\mathrm{i}\mathrm{d}$函数

$$\sigma (x)=\frac{1}{1+e^{-x}}$$

该函数通常用于产生伯努利分布中的参数$\varphi$，因为其范围是$(0,1)$。当函数的自变量变得很大或者很小的时候，会出现饱和的情况，也就意味着它对输入的微小改变变得不敏感。

$\mathrm{s}\mathrm{o}\mathrm{f}\mathrm{t}\mathrm{p}\mathrm{l}\mathrm{u}\mathrm{s}$函数

$$\zeta (x)=\log (1+e^x)$$

该函数名来源于另一个函数$\mathrm{R}\mathrm{e}\mathrm{L}\mathrm{U}$
x + = max ⁡ { 0 , x } x^+ = \max\{0, x\} x+=max{ 0,x}
该函数可用于产生正态分布的参数$\mu ,\sigma$，其范围是$(0,\infty )$。

贝叶斯规则

已知$P(\text{y}\mid \text{x})$计算$P(\text{x}\mid \text{y})$.
$$P(\text{x}\mid \text{y})=\frac{P(\text{y}\mid \text{x})P(\text{x})}{P(\text{y})}=\frac{P(\text{y}\mid \text{x})P(\text{x})}{{\sum }_{x}P(\text{y}\mid \text{x}=x)P(\text{x}=x)}$$
无需知道$P(\text{y})$的值。

信息论

思想：一件较不可能发生的事比一件较可能发生的事所包含的信息量大。

信息需要满足三个条件：

• 非常可能发生的事件信息量要比较少，并且极端情况下，确保能够发生的事件应该没有信息量。
• 较不可能发生的事件具有更高的信息量；
• 独立事件应具有增量信息。例如，投掷的硬币两次正面朝上传递的信息量，应该是投掷一次硬币正面朝上的信息量的两倍。

自信息：一个事件$\text{x}=x$的自信息为
$$I(x)=-\log P(x)$$
用$\log$ 来表示自然对数，其底数为$e$。信息量的单位是奈特$(\mathrm{n}\mathrm{a}\mathrm{t}\mathrm{s})$。若以$2$为底，则单位是比特$(\mathrm{b}\mathrm{i}\mathrm{t}\mathrm{s})$。

香农熵：用于对整个概率分布中的不确定性总量进行量化。也就是编码理论中的最优编码长度。
$$H(\text{x})=-{\mathbb{E}}_{x\sim P(x)}[\log P(x)]=-\sum _{x}P(x)\log P(x)$$

# 香农熵 plot
p = np.linspace(1e-6, 1 - 1e-6, 100)
entropy = - p * np.log(p)
plt.figure(figsize=(6, 4))
plt.plot(p, entropy)
plt.xlabel('p')
plt.ylabel('entropy(nats)')
plt.savefig('entropy.jpg', dpi=300)
plt.show()

def Shannon_Entropy(string):
    """
    计算最优编码长度
    :param string:
    :return:
    """
    entropy = 0
    for ch in range(0, 256):
        Px = string.count(chr(ch)) / len(string)
        if Px > 0:
            entropy += -Px * math.log(Px, 2)
    return entropy


message = "".join([chr(random.randint(0, 64)) for i in range(100)])
print(message)
# .1??@41-'7;<;!
# / +
# =;9!<"6#0%3
print(Shannon_Entropy(message))
# 5.419819909835648

联合熵：同时考虑多个事件的熵，多个随机变量
$$H(X,Y)=-\sum _{x,y}P(x,y)\log P(x,y)$$
条件熵：一件事情发生的情况下，另一个事件的熵，
$$H(X\mid Y)=-\sum _{y}P(y)\sum _{x}P(x\mid y)\log P(x\mid y)$$
互信息：表示两件事情信息相交的部分。
$$I(X,Y)=H(X)+H(Y)-H(X,Y)$$
信息变差：表示两件事情信息不相交的部分。
$$V(X,Y)=H(X,Y)-I(X,Y)$$
$\mathrm{K}\mathrm{L}$散度：用于衡量两个分布$P(\text{x})$和$Q(\text{x})$之间差距，
$$D_{\mathrm{K}\mathrm{L}}(P\mid \mid Q)={\mathbb{E}}_{\text{x}\sim P}\left[\log \frac{P(x)}{Q(x)}\right]=\sum P(x)\log \frac{P(x)}{Q(x)}$$

$$D_{\mathrm{K}\mathrm{L}}(Q\mid \mid P)={\mathbb{E}}_{\text{x}\sim Q}\left[\log \frac{Q(x)}{P(x)}\right]=\sum Q(x)\log \frac{Q(x)}{P(x)}$$

显然，$D_{\mathrm{K}\mathrm{L}}(P\mid \mid Q)\ne D_{\mathrm{K}\mathrm{L}}(Q\mid \mid P)$。

$★$注意：在离散型随机变量下，$\mathrm{K}\mathrm{L}$散度衡量的是当我们使用一种被设计成能够使得概率分布$Q$产生的消息的长度的最小编码，发送包含由概率分布$P$产生的符号的消息时，所需要的额外信息量。

from scipy.stats import entropy  # 内置KL散度
import numpy as np


def KL_Divergence(p, q):
    """D(P || Q)"""
    return np.sum(np.where(p != 0, p * np.log(p / q), 0))


p = np.array([0.1, 0.9])
q = np.array([0.1, 0.9])

print(KL_Divergence(p, q))  # 0.0

print(entropy(p, q))  # 0.0  
# 两个分布一样

from scipy.stats import norm, entropy
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(1, 10, 1000)
y1 = norm.pdf(x, 3, 0.4)
y2 = norm.pdf(x, 6, 0.4)
P = y1 + y2  # 构造p(x)

KL_PQ = []
KL_QP = []
Q_list = []
for mu in np.linspace(0, 10, 100):
    for sigma in np.linspace(0.1, 5, 50):
        Q = norm.pdf(x, mu, sigma)
        Q_list.append(Q)
        KL_PQ.append(entropy(P, Q))
        KL_QP.append(entropy(Q, P))
# 寻找Q使得KL_PQ最小
KL_PQ_min = np.argmin(KL_PQ)
# 寻找Q使得KL_QP最小
KL_QP_min = np.argmin(KL_QP)

plt.rcParams['font.family'] = ["Times New Roman"]
fig, axes = plt.subplots(1, 2, figsize=(10, 4))
axes[0].plot(x, P / 2, 'g-', label="$\\bf P(x)$")
axes[0].plot(x, Q_list[KL_PQ_min], 'b-.', label="$\\bf {Q^{*}(x)}$")
axes[0].set_ylim(0, 1.2)
axes[0].set_xlabel("$\\bf x$")
axes[0].set_ylabel("$\\bf P(x)$")
axes[0].set_title("$\\bf \\rm \\arg\\min_{Q}(KL(P||Q))$")
axes[0].legend()

axes[1].plot(x, P / 2, 'g-', label="$\\bf P(x)$")
axes[1].plot(x, Q_list[KL_QP_min], 'r-.', label="$\\bf {Q^{*}(x)}$")
axes[1].set_ylim(0, 1.2)
axes[1].set_xlabel("$\\bf x$")
axes[1].set_ylabel("$\\bf P(x)$")
axes[1].set_title("$\\bf \\rm \\arg\\min_{Q}(KL(Q||P))$")
axes[1].legend()

plt.savefig("./images/KL.jpg", dpi=300)
plt.show()

交叉熵：一个和$\mathrm{K}\mathrm{L}$散度联系紧密的量是交叉熵。含义就是实际输出概率$Q$和期望输出概率$P$之间的距离。
$$\begin{array}{rl}H(P,Q)& =H(P)+D_{\mathrm{K}\mathrm{L}}(P\mid \mid Q)=-{\mathbb{E}}_{x\sim P}[\log Q(x)]\\ & =-\sum _{x}P(x)\log Q(x)\end{array}$$
对于二分类来说，其交叉熵计算方式如下
$$H(P,Q)=-\frac{1}{N}\sum _{x}P(x)\log Q(x)+(1-P(x))\log (1-Q(x))$$

其中，$P(x)$表示样本$x$的期望(真实)标签，正类为1，负类为0；$Q(x)$表示模型实际预测该样本$x$类别为正的概率。$N$表示样本个数。

假设有$3$个样本，其真实类别标签是$P=(1,0,1)$ ，实际预测样本为正的概率为$Q=(0.8,0.1,0.7)$。计算期望输出和实际输出之间的交叉熵，如下

from sklearn.metrics import log_loss
import numpy as np

P = np.array([1, 0, 1])
Q1 = np.array([0.8, 0.1, 0.7])
Q2 = np.array([0.1, 0.7, 0.3])
# binary_ent = 0.0
# for i in range(P.size):
#     binary_ent += P[i] * np.log(Q1[i]) + (1 - P[i]) * np.log(1 - Q1[i])
# print(-binary_ent)  # 0.6851790109107685
binary_ent1 = - P * np.log(Q1) - (1 - P) * np.log(1 - Q1)
binary_ent2 = - P * np.log(Q2) - (1 - P) * np.log(1 - Q2)

print(binary_ent1.sum() / P.size)  # 0.22839300363692283
print(binary_ent2.sum() / P.size)  # 1.5701769005486392
# np.log 为自然对数

print(log_loss(P, Q1))
print(log_loss(P, Q2))
# 0.22839300363692283
# 1.5701769005486392

从上述结果中可以看出预测值$Q1$的交叉熵明显比$Q2$的小，说明$Q1$的预测更接近期望值。

对于多分类来说，其交叉熵计算方式如下
$$H(P,Q)=-\frac{1}{N}\sum _{i=1}^N\sum _{j=1}^{M}P(x_{i,j})\log (Q(x_{i,j}))$$
其中，$P(x_{i,j})$表示样本$x_i$真实类别标签为$j$则为$1$，否则为$0$；$Q(x_{i,j})$表示样本$x_i$预测为第$j$类的概率，$N$为样本数量，$M$为类别标签数量。

假设有$3$个样本，总共有$0\sim 9$共$10$个类别标签，$P$表示样本真实标签，是一个向量；$Q$表示模型对每个样本进行类别预测的值，是一个$3$行$10$列的矩阵，每行表示对样本$i$的类别预测概率值组成的向量，计算交叉熵。

import numpy as np
from sklearn.metrics import log_loss
from sklearn.preprocessing import LabelBinarizer

P = np.array(['1', '5', '9'])  # 样本的真实标签

Q = np.array([
    [0.1, 0.7, 0, 0, 0.01, 0.19, 0, 0, 0, 0],
    [0, 0.1, 0, 0.1, 0, 0.8, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0.1, 0, 0.9]
])  # Q[i]是一个向量 Q[i][j]表示P[i]被预测为j类的概率

labels = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']  # 标签集合
sklearn_multi_ent = log_loss(P, Q, labels=labels)
print(sklearn_multi_ent)  # 0.22839300363693002

# 根据公式计算
# 先对类别标签进行二值化为0&1  数字标签和非数字标签都需要
LB = LabelBinarizer()
LB.fit(labels)
bin_P = LB.transform(P)  # 真实标签进行转换
print(bin_P)
# [[0 1 0 0 0 0 0 0 0 0]
#  [0 0 0 0 0 1 0 0 0 0]
#  [0 0 0 0 0 0 0 0 0 1]]

N = P.size
M = len(labels)
eps = 1e-15  # 预测概率的控制值

multi_ent = 0.0
for i in range(N):
    for j in range(M):
        if Q[i, j] > 1 - eps:
            Q[i, j] = 1 - eps
        if Q[i, j] < eps:
            Q[i, j] = eps
        multi_ent += -bin_P[i, j] * np.log(Q[i, j])

print(multi_ent / N)  # 0.22839300363692283

假设$P$是期望(真实)分布，$Q$是模型(实际)分布，最小化交叉熵$H(P,Q)$就能让模型分布逼近真实分布。

参考资料

[1] 《深度学习》花书
[2] 相关github