《统计学习方法》第四章，朴素贝叶斯

▶ 朴素贝叶斯方法来进行分类

● 代码

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from mpl_toolkits.mplot3d.art3d import Poly3DCollection
from matplotlib.patches import Rectangle
import operator
import warnings

warnings.filterwarnings("ignore")
dataSize = 10000
trainRatio = 0.3

def dataSplit(x, y, part):                                                          # 将数据集按给定索引分为两段
    return x[:part], y[:part],x[part:],y[part:]

def myColor(x):                                                                     # 颜色函数，用于对散点染色
    r = np.select([x < 1/2, x < 3/4, x <= 1, True],[0, 4 * x - 2, 1, 0])
    g = np.select([x < 1/4, x < 3/4, x <= 1, True],[4 * x, 1, 4 - 4 * x, 0])
    b = np.select([x < 1/4, x < 1/2, x <= 1, True],[1, 2 - 4 * x, 0, 0])
    return [r**2,g**2,b**2]

def createData(dim, option, kind, count = dataSize):                                # 创建数据集，给定属性维度，每属性取值数，类别数，样本数
    np.random.seed(103)        
    X = np.random.randint(option, size = [count, dim])
    if kind == 2:                           
        Y = ((3 - 2 * dim) * X[:,0] + 2 * np.sum(X[:,1:], 1) > 0.5).astype(int)
    else: 
        randomVector = np.random.rand(dim)
        randomVector /= np.sum(randomVector)
        Y = (np.sum(X * randomVector,1) * kind / option).astype(int)                # 各类别不够均匀    
    #print(output)
    print("dim = %d, option = %d, kind = %d, dataSize = %d"%(dim, option, kind, count))
    kindCount = np.zeros(kind ,dtype = int)                                         # 各类别的占比
    for i in range(count):
        kindCount[Y[i]] += 1
    for i in range(kind):
        print("kind %d -> %4f"%(i, kindCount[i]/count)) 
    return X, Y

def naïveBayes(dataX, dataY , λ = 1):               # λ 为平滑系数，0 时为极大似然估计，1 时为拉普拉斯平滑                              
    count, dim = np.shape(dataX)    
    option = len(set(dataX[:,0]))                   # 这里默认所有属性的取值个数相同
    kind = len(set(dataY))                          # 实际可以改进为一个列表来记录
    pY = np.zeros(kind)                             # 先验概率表计数
    for i in dataY:        
        pY[i] += 1         
    pX = np.zeros([kind, dim, option])              # 条件概率表，kind 行 dim 列（和 pY 能直接相乘）option 格，小格内为该属性各取值的计数
    for i in range(count):                          # 计数
        for col in range(dim):
            pX[dataY[i], col, dataX[i, col]] += 1                       
    for row in range(kind):                         # 逐小格归一化，用到了 pY 计数
        for col in range(dim):
            pX[row,col,:] = (pX[row,col,:] + λ)/(pY[row] + option * λ)
    
    pY = (pY + λ) / (np.sum(pY) + kind * λ)         # 先验概率表归一化
    return pX, pY

def judge(x, para):                                 # 计算样本落入每种类别的后验概率，选择概率最大的那项
    table = para[1].copy()                          # 艹，必须用浅拷贝不能用等号，否则 para[1] 会随着 table 变化
    for i in range(len(x)):
        table *= para[0][:, i, x[i]]
    return np.argmax(table)
   
def test(dim, option, kind):
    allX, allY = createData(dim, option, kind)            
    trainX, trainY, testX, testY = dataSplit(allX, allY, int(dataSize * trainRatio)) 
    para = naïveBayes(trainX, trainY)                               
    myResult = [ judge(testX[i], para) for i in range(len(testX)) ] # 存放测试结果
    
    errorRatio  = np.sum((np.array(myResult) != testY).astype(int)) / (dataSize * (1 - trainRatio)) # 计算分类错误率
    print("errorRatio = %4f"%errorRatio)                                                            # 离散取值，不画图了

if __name__ == '__main__':    
    test(1, 2, 2)                                   # 1 属性 2 取值，分 2 类
    
    test(2, 3, 2)    
    test(2, 3, 4)
    
    test(3, 3, 2)           
    test(3, 4, 5)
    
    test(4, 3, 2)
    test(4, 5, 6)
    
    test(5, 3, 6)    

● 输出结果。速度非常快，可见随着属性数和每个属性的取值数的递增，分类错误率很快上涨。

dim = 1, option = 2, kind = 2, dataSize = 10000
kind 0 -> 0.498600
kind 1 -> 0.501400
errorRatio = 0.000000
dim = 2, option = 3, kind = 2, dataSize = 10000
kind 0 -> 0.446700
kind 1 -> 0.553300
errorRatio = 0.000000
dim = 2, option = 3, kind = 4, dataSize = 10000
kind 0 -> 0.336700
kind 1 -> 0.330100
kind 2 -> 0.333200
kind 3 -> 0.000000
errorRatio = 0.000000
dim = 3, option = 3, kind = 2, dataSize = 10000
kind 0 -> 0.444400
kind 1 -> 0.555600
errorRatio = 0.071714
dim = 3, option = 4, kind = 5, dataSize = 10000
kind 0 -> 0.144300
kind 1 -> 0.430700
kind 2 -> 0.315600
kind 3 -> 0.109400
kind 4 -> 0.000000
errorRatio = 0.205000
dim = 4, option = 3, kind = 2, dataSize = 10000
kind 0 -> 0.452500
kind 1 -> 0.547500
errorRatio = 0.070429
dim = 4, option = 5, kind = 6, dataSize = 10000
kind 0 -> 0.056700
kind 1 -> 0.269100
kind 2 -> 0.415800
kind 3 -> 0.229900
kind 4 -> 0.028500
kind 5 -> 0.000000
errorRatio = 0.310714
dim = 5, option = 3, kind = 6, dataSize = 10000
kind 0 -> 0.096400
kind 1 -> 0.399900
kind 2 -> 0.408000
kind 3 -> 0.092300
kind 4 -> 0.003400
kind 5 -> 0.000000
errorRatio = 0.190857