混合高斯模型和EM算法

于2021年5月15日2021年5月15日由Sukuna发布

一些概率的解释

在这个条件下,我们把图片上没有动物的角的概率作为先验概率,图片上有动物的角并且是犀牛称为类条件概率

类条件概率是就是已知一个条件下，结果发生的概率。条件概率实际上把一个完整的问题集合S通过特征进行了划分，划分成S1/S2/S3…。类条件概率中的类指的是把造成结果的所有原因一一进行列举，分别讨论。

先验概率:事情还没有发生，根据以往经验和分析得到的概率，在事情发生之前，得到的事情（结果）发生的概率。比如，一次抛硬币实验，我们认为正面朝上的概率是0.5，这就是一种先验概率，在抛硬币前，我们只有常识。

后验概率:事情已经发生了，结果的发生的原因有很多，判断结果的发生是由哪个原因引起的概率

贝叶斯决策论

假设有N种判别标记, $y={\theta_1,\theta_2,\theta_3......\theta_N}$ , $\lambda_{ij}$ 为将一个真实的标记 $\theta_j$ 错误地分成了 $\theta_i$ 地的损失,基于后验概率可以定义把x分到 $c_i$ 所产生的期望损失

于是有: $R(\theta_i|x)=\sum_{j=1}^N\lambda_{ij}P(\theta_j|x)$

在这里我们一般当i=j的时候, $\lambda_{ij}=0$ ,i≠j的时候, $\lambda_{ij}=1$

所以说可以写出总体风险的表达式:

$R(h)=\mathcal{E}_x[R(h(x)|x)]$

对于每个样本x,如果我们能最小化条件风险,我们就可以让总体风险减小,这个时候判定的准则就是最优的,因为我们的风险比较低,用数学式子表达一下: $h^*(x)=argminR(c|x)$

计算后验概率是我们需要考虑的,这里有两个模型需可以考虑,一个是判别模型,就是直接构造概率分布: $P(x,\theta)$ ,一个是生成模型,下面进行叙述:

在收到某个消息之后，接收端所了解到的该消息发送的概率称为后验概率。
随机变量X的概率分布为 $f(x|\theta)$ ，先验概率分布为 $f(\theta)$ (样本空间中各类样本所占的比例)，根据贝叶斯定理，后验概率分布为 $f(\theta|x)$ :这里的逻辑内涵是: $\theta$ 是输出(分类的标准), $x$ 是输入,那么 $P(x|\theta)$ 是类条件概率,我们又称作似然.

极大似然估计

现在我们已经有训练集 $D$ ,并且 $P(x|\theta)$ 可以用一组向量进行表示,训练集的样本是独立同分布的:

现在我我们要利用训练集来估计参数,假设参数我们用 $\theta_c$ 表示:,这个时候我们定义似然: $\prod_{x\in D_c}P(x|\theta_c)$ ,这个时候我们就可以找到使得似然值最大的 $\theta_c$

注意:这个时候 $\theta_c$ 是类先验概率里面的一个参数,不能完全等同于c,这里只是说明方便把它替换了一下而已(因为贝叶斯学派认为 $\theta$ 也是有分布的)

朴素贝叶斯分类器

从上面的分析中我们知道,我们很难得到 $P(x|c)$ ,因为P(x|c)是需要我们构建复杂的模型进行生成的,我们假设x是独立同分布的,那么有:

$P(c|x)=\frac{P(c)}{P(x)}\proc _{i=1}^d P(x_i|c)$

,朴素贝叶斯分类器就是基于训练集D来估计先验概率和类条件概率

首先是先验概率:

$P(c)=\frac{|D_c|}{|D|}$

对于离散属性:我们让其条件概率为c类的所有元素之和和c类上取值为 $x_i$ 的集合
对于连续属性:默认其为Gauss分布

根据独立同分布原理,我们可以把类条件概率刻画为

$P(x|c)=\proc P(x_i|c)$

贝叶斯分类器的实践

下面用周志华的西瓜分类器3.0来作为例子:

编号,色泽,根蒂,敲声,纹理,脐部,触感,密度,含糖率,好瓜
1,青绿,蜷缩,浊响,清晰,凹陷,硬滑,0.697,0.46,是
2,乌黑,蜷缩,沉闷,清晰,凹陷,硬滑,0.774,0.376,是
3,乌黑,蜷缩,浊响,清晰,凹陷,硬滑,0.634,0.264,是
4,青绿,蜷缩,沉闷,清晰,凹陷,硬滑,0.608,0.318,是
5,浅白,蜷缩,浊响,清晰,凹陷,硬滑,0.556,0.215,是
6,青绿,稍蜷,浊响,清晰,稍凹,软粘,0.403,0.237,是
7,乌黑,稍蜷,浊响,稍糊,稍凹,软粘,0.481,0.149,是
8,乌黑,稍蜷,浊响,清晰,稍凹,硬滑,0.437,0.211,是
9,乌黑,稍蜷,沉闷,稍糊,稍凹,硬滑,0.666,0.091,否
10,青绿,硬挺,清脆,清晰,平坦,软粘,0.243,0.267,否
11,浅白,硬挺,清脆,模糊,平坦,硬滑,0.245,0.057,否
12,浅白,蜷缩,浊响,模糊,平坦,软粘,0.343,0.099,否
13,青绿,稍蜷,浊响,稍糊,凹陷,硬滑,0.639,0.161,否
14,浅白,稍蜷,沉闷,稍糊,凹陷,硬滑,0.657,0.198,否
15,乌黑,稍蜷,浊响,清晰,稍凹,软粘,0.36,0.37,否
16,浅白,蜷缩,浊响,模糊,平坦,硬滑,0.593,0.042,否
17,青绿,蜷缩,沉闷,稍糊,稍凹,硬滑,0.719,0.103,否

import numpy as np
import pandas as pd

dataset = pd.read_csv('3.0.csv', delimiter=",")
del dataset['编号']
print(dataset)
#X保存了所有除了是和否的元素
X = dataset.values[:, :-1]
m, n = np.shape(X)
print(m,n)
#做四舍五入计算
for i in range(m):
    X[i, n - 1] = round(X[i, n - 1], 3)
    X[i, n - 2] = round(X[i, n - 2], 3)
#y保存了结果
y = dataset.values[:, -1]
columnName = dataset.columns
colIndex = {}
#每一列的元素进行编号
for i in range(len(columnName)):
    colIndex[columnName[i]] = i

Pmap = {}  # 函数P很耗时间，而且经常会求一样的东西，因此我加了个记忆化搜索，用map存一下，避免重复计算，这里保存的是离散值
kindsOfAttribute = {}  # kindsOfAttribute[0] = 3,因为有3种不同的类型的"色泽"
for i in range(n):
    kindsOfAttribute[i] = len(set(X[:, i]))
continuousPara = {}  # 记忆一些参数的连续数据,以避免重复计算
#保存好的和不好的元素
goodList = []
badList = []
for i in range(len(y)):
    if y[i] == '是':
        goodList.append(i)
    else:
        badList.append(i)

import math


def P(colID, attribute, C):  # P(colName=attribute|C) P(色泽=青绿|是)
    #已经预测过了,就直接返回一个三元组就行了
    if (colID, attribute, C) in Pmap:
        return Pmap[(colID, attribute, C)]
    curJudgeList = []
    if C == '是':
        curJudgeList = goodList
    else:
        curJudgeList = badList
    ans = 0
    #colID>=6代表的是连续型变量
    if colID >= 6:
        mean = 1
        std = 1
        if (colID, C) in continuousPara:
            curPara = continuousPara[(colID, C)]
            mean = curPara[0]
            std = curPara[1]
        else:
            #求平均值和方差
            curData = X[curJudgeList, colID]
            mean = curData.mean()
            std = curData.std()
            # print(mean,std)
            #保存元素
            continuousPara[(colID, C)] = (mean, std)
        #返回要测试的密度
        ans = 1 / (math.sqrt(math.pi * 2) * std) * math.exp((-(attribute - mean) ** 2) / (2 * std * std))
    else:
        for i in curJudgeList:
            if X[i, colID] == attribute:
                ans += 1
        ans = (ans + 1) / (len(curJudgeList) + kindsOfAttribute[colID])
    Pmap[(colID, attribute, C)] = ans
    # print(ans)
    return ans


def predictOne(single):
    #先验概率
    ansYes = math.log2((len(goodList) + 1) / (len(y) + 2))
    ansNo = math.log2((len(badList) + 1) / (len(y) + 2))
    for i in range(len(single)):  # 书上是连乘，但在实践中要把“连乘”通过取对数的方式转化为“连加”以避免数值下溢
        ansYes += math.log2(P(i, single[i], '是'))
        ansNo += math.log2(P(i, single[i], '否'))
    # print(ansYes,ansNo,math.pow(2,ansYes),math.pow(2,ansNo))
    if ansYes > ansNo:
        return '是'
    else:
        return '否'


def predictAll(iX):
    predictY = []
    for i in range(m):
        predictY.append(predictOne(iX[i]))
    return predictY


predictY = predictAll(X)
print(y)
print(np.array(predictAll(X)))
#输出测试结果
confusionMatrix = np.zeros((2, 2))
for i in range(len(y)):
    if predictY[i] == y[i]:
        if y[i] == '否':
            confusionMatrix[0, 0] += 1
        else:
            confusionMatrix[1, 1] += 1
    else:
        if y[i] == '否':
            confusionMatrix[0, 1] += 1
        else:
            confusionMatrix[1, 0] += 1
print(confusionMatrix)
acc = (confusionMatrix[0][0]+confusionMatrix[1][1])/17
acc = str(acc)
print('acc: '+acc)

输出: