监督学习之朴素贝叶斯算法

1.条件概率

在已知事件A发生的条件下，事件B发生的概率成为条件概率，用P（A|B)表示，公式如下：

2.全概率公式

它的含义是，如果A和A’构成样本空间的一个划分，那么事件B的概率，就等于A和A’的概率分别乘以B对这两个事件的条件概率之和。公式如下：

1.贝叶斯推断

对条件概率公式进行变形，可以得到如下形式：

我们把P(A)称为"先验概率"（Prior probability），即在B事件发生之前，我们对A事件概率的一个判断。
P(A|B)称为"后验概率"（Posterior probability），即在B事件发生之后，我们对A事件概率的重新评估。
P(B|A)/P(B)称为"可能性函数"（Likelyhood），这是一个调整因子，使得预估概率更接近真实概率。

1.朴素贝叶斯推断

设A,B两个事件相互独立，则*P(AB)=P(A)P(B)

#初始版本
import numpy as np
from functools import reduce
def loadDataSet():
    X_train=np.array([[0,0,0,0],[0,0,0,1],[0,0,1,0],[0,0,1,1],
                      [0,1,0,0],[0,1,0,1],[0,1,1,0],[0,1,1,1],
                      [1,0,0,1],[1,0,1,0],[1,0,1,1],[1,1,0,1],
                      [1,1,1,0],[1,1,1,1]])
    y=np.array([0,0,0,1,
                0,1,1,1,
                1,1,1,1,
                1,1])
    return X_train,y

def Classifier(x,y):
    p1num=np.zeros(len(x[0]))
    p1matrix=0
    p0num=np.zeros(len(x[0]))
    p0matrix=0
    for i in range(len(x)):
        if y[i]==1:
            p1num+=x[i]
            p1matrix+=sum(x[i])
        else:
            p0num+=x[i]
            p0matrix+=sum(x[i])
    # 可能出现数据下溢出，这是由于太多很小的数相乘造成的。
    #在test函数中，两个小数相乘，越乘越小，这样就造成了下溢出。
    p1V=p1num/p1matrix
    p0V=p0num/p0matrix
    p1Class=sum(y)/float(len(x))
    return p0V,p1V,p1Class

def test(data,p0v,p1v,p1c):
    p1 = reduce(lambda x,y:x*y,data*p1v)*p1c
    p0 = reduce(lambda  x,y:x*y,data*p0v)*(1-p1c)
    print("p0:",p0)
    print("p1:",p1)
    if p1 > p0:
        return 1
    else:
        return 0

def main():
    x,y=loadDataSet()
    p0v,p1v,p1class=Classifier(x,y)
    print("p0v:",p0v)
    print("p1v:", p1v)
    print("p1class:", p1class)
    testData = np.array([0,0,1,1])
    res=test(testData,p0v,p1v,p1class)
    if res==0:
        print("测试数据属于第0类")
    else:
        print("测试数据属于第1类")
if __name__=="__main__":
    main()

运行结果如下：

import numpy as np
from functools import reduce

'''
初始化数据
X_train:训练数据
y:数据对应的标签
'''
def loadDataSet():
    # X_train=np.array([[1,1,0,1],[0,1,0,1],[0,0,1,1],[1,0,1,0]])
    # y=np.array([1,0,1,0])
    X_train=np.array([[0,0,0,0],[0,0,0,1],[0,0,1,0],[0,0,1,1],
                      [0,1,0,0],[0,1,0,1],[0,1,1,0],[0,1,1,1],
                      [1,0,0,1],[1,0,1,0],[1,0,1,1],[1,1,0,1],
                      [1,1,1,0],[1,1,1,1]])
    y=np.array([0,0,0,1,
                0,1,1,1,
                1,1,1,1,
                1,1])
    return X_train,y

'''
分类器
p1num:属于类别1的每列数据求和
p0num:属于类别0的每列数据求和
p1matrix:属于类别1的标签个数
p1matrix:属于类别0的标签个数
p1class:属于类别1标签的概率
'''
def Classifier(x,y):
    p1num=np.ones(len(x[0]))
    p0num=np.ones(len(x[0]))
    #将所有词的出现数初始化为1，并将分母初始化为2
    p1matrix=2.0
    p0matrix=2.0
    for i in range(len(x)):
        if y[i]==1:
            p1num+=x[i]
            p1matrix+=sum(x[i])
        else:
            p0num+=x[i]
            p0matrix+=sum(x[i])
	#为了防止数据下溢出，使用log函数
    p1V=np.log(p1num/p1matrix)
    p0V=np.log(p0num/p0matrix)
    p1Class=sum(y)/float(len(x))
    return p0V,p1V,p1Class

'''
测试结果
p1:测试数据属于类别1的概率
p0:测试数据属于类别0的概率
概率相乘等于log函数相加[log(a*b)=log(a)+log(b)]
'''
def test(data,p0v,p1v,p1c):
    p1 = sum(data*p1v)+np.log(p1c)
    p0 = sum(data*p0v)+np.log(1-p1c)
    print("p0:",p0)
    print("p1:",p1)
    if p1 > p0:
        return 1
    else:
        return 0


'''
主函数
'''
def main():
    x,y=loadDataSet()
    p0v,p1v,p1class=Classifier(x,y)
    print("p0v:",p0v)
    print("p1v:", p1v)
    print("p1class:", p1class)
    testData = np.array([1,0,1,0])
    res=test(testData,p0v,p1v,p1class)
    if res==0:
        print("测试数据属于第0类")
    else:
        print("测试数据属于第1类")

'''
函数入口
'''
if __name__=="__main__":
    main()

运行结果如下：