统计学习方法 | 朴素贝叶斯法

目录

一、朴素贝叶斯法的原理 

二、极大似然估计下的朴素贝叶斯算法python实现 

三、贝叶斯估计下的朴素贝叶斯算法python实现

一、朴素贝叶斯法的原理 

二、极大似然估计下的朴素贝叶斯算法python实现 

import numpy as np
 
def naiveBayes(X,Y,n,x):
    '''X代表的是各个特征的特征值
       Y代表类标记
       n代表特征类别
       x代表需要预测的数据点'''
    '''得到各特征和类标记的类别'''
    # 各特征X的类别
    xfeature = []
    for i in X:
        xfeature.append(np.unique(i))
    # 类标记Y的类别
    yfeature = np.unique(Y)
 
    '''计算各特征和类标记所对应的类别数'''
    # 各特征X的类别数
    xfeaturenum = []
    for i in xfeature:
        xfeaturenum.append(len(i))
    # 类标记的类别数
    yfeaturenum = len(yfeature)
 
    '''计算各个类标记所占的比例'''
    N = len(Y)  # 训练数据的总量
    PY = []  # 存储各个类标记Y所占的比例
    for i in yfeature:
        a = 0  # 计数器
        for j in Y:
            if j == i:
                a += 1
        PY.append(round(a / N, 6))  # 最多保留6位小数
 
    '''计算各个类标记Y下取得不同特征值X的比例'''
    PYX = []
    for i in range(yfeaturenum):
        P = []  # 存储在不同类标记下各个特征的比例
        py = PY[i]  # 对应类标记的概率
        for j in range(n):
            Q = []  # 存储在某个类标记下某个特征取不同特征值对应的比例
            for k in xfeature[j]:  # 取X的特征
                b = 0  # 计数器
                for h in range(N):
                    if Y[h] == yfeature[i] and X[j][h] == k:
                        b += 1
                Q.append(round((b / N) / py, 6))  # 最多保留6位小数
            P.append(Q)
        PYX.append(P)
 
    '''显示训练结果'''
    print("----------先验概率----------")
    for i in range(yfeaturenum):
        print("P(Y={})={}".format(yfeature[i], PY[i]), end="  ")
    print("\n")
    for i in range(yfeaturenum):
        for j in range(n):
            v = xfeaturenum[j]
            for k in range(v):
                print("P(X={}|Y={})={}".format(xfeature[j][k], yfeature[i], PYX[i][j][k]), end="  ")
            print("\n")
 
    '''对所给数据利用贝叶斯分类器进行预测'''
    '''计算所给数据在各个可能的类别下的后验概率'''
    R = []  # 存储数据在各个可能的类别下的后验概率
    # 返回各个特征相对应的索引
    index = []
    for i in range(n):
        index.append((xfeature[i].tolist()).index(x[i]))
    # 计算相应的后验概率
    for i in range(n):
        r = PY[i]
        for j in range(n):
            r = r * PYX[i][j][index[j]]
        R.append(round(r, 6))  # 最多保留6位小数
 
    '''输出后验概率'''
    print("----------后验概率----------")
    for i in range(n):
        print("P(Y={})P(X1={}|Y={})P(X2={}|Y={})={}".format(yfeature[i], xfeature[0][index[0]],
                                                            yfeature[i], xfeature[1][index[1]], yfeature[i], R[i],
                                                            end="  "))
    print("\n")
 
    '''输出利用贝叶斯分类器预测得到的结果'''
    maxindex = R.index(max(R))
    w = yfeature[maxindex]
    print("----------预测结果----------")
    print("数据点{}对应的类别是：{}".format(x, w))
 
if __name__=="__main__":
    '''训练数据'''
    X1 = [1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3]  # 特征1
    X2 = ['S', 'M', 'M', 'S', 'S', 'S', 'M', 'M', 'L', 'L', 'L', 'M', 'M', 'L', 'L']  # 特征2
    X = [X1, X2]
    n = 2  # 特征量
    Y = [-1, -1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1]  # 分类结果
 
    '''给定数据点利用贝叶斯分类器进行预测'''
    x = [2, 'S']
 
    '''调用朴素贝叶斯分类器'''
    naiveBayes(X,Y,n,x)

三、贝叶斯估计下的朴素贝叶斯算法python实现

import numpy as np
 
def naiveBayes(X,Y,n,x):
    '''X代表的是各个特征的特征值
       Y代表类标记
       n代表特征类别
       x代表需要预测的数据点'''
    '''得到各特征和类标记的类别'''
    # 各特征X的类别
    xfeature = []
    for i in X:
        xfeature.append(np.unique(i))
    # 类标记Y的类别
    yfeature = np.unique(Y)
 
    '''计算各特征和类标记所对应的类别数'''
    # 各特征X的类别数
    xfeaturenum = []
    for i in xfeature:
        xfeaturenum.append(len(i))
    # 类标记的类别数
    yfeaturenum = len(yfeature)
 
 
    '''定义贝叶斯估计中z的值，，这里取1，即采用拉普拉斯光滑'''
    z=1
 
    '''计算各个类标记所占的比例'''
    N = len(Y)  # 训练数据的总量
    ynum=[]     #存储各个类标记的数量
    PY = []  # 存储各个类标记Y所占的比例
    for i in yfeature:
        a = 0  # 计数器
        for j in Y:
            if j == i:
                a += 1
        ynum.append(a)
        PY.append(round((a+z) / (N+z*yfeaturenum), 6))  # 最多保留6位小数
 
    '''计算各个类标记Y下取得不同特征值X的比例'''
    PYX = []
    for i in range(yfeaturenum):
        P = []  # 存储在不同类标记下各个特征的比例
        py = PY[i]  # 对应类标记的概率
        for j in range(n):
            Q = []  # 存储在某个类标记下某个特征取不同特征值对应的比例
            for k in xfeature[j]:  # 取X的特征
                b = 0  # 计数器
                for h in range(N):
                    if Y[h] == yfeature[i] and X[j][h] == k:
                        b += 1
                Q.append(round((b+z)/(ynum[i]+z*xfeaturenum[j]), 6))  # 最多保留6位小数
            P.append(Q)
        PYX.append(P)
 
    '''显示训练结果'''
    print("----------先验概率----------")
    for i in range(yfeaturenum):
        print("P(Y={})={}".format(yfeature[i], PY[i]), end="  ")
    print("\n")
    for i in range(yfeaturenum):
        for j in range(n):
            v = xfeaturenum[j]
            for k in range(v):
                print("P(X={}|Y={})={}".format(xfeature[j][k], yfeature[i], PYX[i][j][k]), end="  ")
            print("\n")
 
    '''对所给数据利用贝叶斯分类器进行预测'''
    '''计算所给数据在各个可能的类别下的后验概率'''
    R = []  # 存储数据在各个可能的类别下的后验概率
    # 返回各个特征相对应的索引
    index = []
    for i in range(n):
        index.append((xfeature[i].tolist()).index(x[i]))
    # 计算相应的后验概率
    for i in range(n):
        r = PY[i]
        for j in range(n):
            r = r * PYX[i][j][index[j]]
        R.append(round(r, 6))  # 最多保留6位小数
 
    '''输出后验概率'''
    print("----------后验概率----------")
    for i in range(n):
        print("P(Y={})P(X1={}|Y={})P(X2={}|Y={})={}".format(yfeature[i], xfeature[0][index[0]],
                                                            yfeature[i], xfeature[1][index[1]], yfeature[i], R[i],
                                                            end="  "))
    print("\n")
 
    '''输出利用贝叶斯分类器预测得到的结果'''
    maxindex = R.index(max(R))
    w = yfeature[maxindex]
    print("----------预测结果----------")
    print("数据点{}对应的类别是：{}".format(x, w))
 
if __name__=="__main__":
    '''训练数据'''
    X1 = [1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3]  # 特征1
    X2 = ['S', 'M', 'M', 'S', 'S', 'S', 'M', 'M', 'L', 'L', 'L', 'M', 'M', 'L', 'L']  # 特征2
    X = [X1, X2]
    n = 2  # 特征量
    Y = [-1, -1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1]  # 分类结果
 
    '''给定数据点利用贝叶斯分类器进行预测'''
    x = [2, 'S']
 
    '''调用朴素贝叶斯分类器'''
    naiveBayes(X,Y,n,x)