机器学习-04-分类算法-02贝叶斯算法案例

总结

本系列是机器学习课程的系列课程，主要介绍机器学习中分类算法，本篇为分类算法与贝叶斯算法部分。

本门课程的目标

完成一个特定行业的算法应用全过程：

懂业务+会选择合适的算法+数据处理+算法训练+算法调优+算法融合
+算法评估+持续调优+工程化接口实现

参考

贝叶斯定理厉害在哪里？-猴子

机器学习最易懂之贝叶斯模型详解与python实现

机器学习之朴素贝叶斯算法原理+Python实现

图解机器学习 | 朴素贝叶斯算法详解

图解机器学习算法：从入门到精通系列教程

简单，却又反直觉的“三门问题”，暴露出很多人根本不懂“概率”

大数据中的统计学基础——Day3

【ML】朴素贝叶斯分类器及Python手写实现（详细）

机器学习定义

关于机器学习的定义，Tom Michael Mitchell的这段话被广泛引用：
对于某类任务T和性能度量P，如果一个计算机程序在T上其性能P随着经验E而自我完善，那么我们称这个计算机程序从经验E中学习。

贝叶斯算法

贝叶斯公式

贝叶斯案例

不使用sklearn-西瓜集3.0

数据集：西瓜集3.0（来自西瓜书《机器学习 周志华》84页）

数据集的推导过程

数据集：

待测集：

（1）计算先验概率：

（2）计算每个属性的条件概率：

a、离散属性：

b、连续属性：

（3）计算后验概率：

因为0.038>6.80*10­^(-5)，所以朴素贝叶斯分类器将待测样本判别为“好瓜”。

实现过程

（1）加载第三方模块

import numpy as np
import math
import pandas as pd

（2） 定义加载数据集函数

def loadDataSet():
    dataSet=[['青绿', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', 0.697, 0.460, '好瓜'],
             ['乌黑', '蜷缩', '沉闷', '清晰', '凹陷', '硬滑', 0.774, 0.376, '好瓜'],
             ['乌黑', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', 0.634, 0.264, '好瓜'],
             ['青绿', '蜷缩', '沉闷', '清晰', '凹陷', '硬滑', 0.608, 0.318, '好瓜'],
             ['浅白', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', 0.556, 0.215, '好瓜'],            
             ['青绿', '稍蜷', '浊响', '清晰', '稍凹', '软粘', 0.403, 0.237, '好瓜'],               
             ['乌黑', '稍蜷', '浊响', '稍糊', '稍凹', '软粘', 0.481, 0.149, '好瓜'],                
             ['乌黑', '稍蜷', '浊响', '清晰', '稍凹', '硬滑', 0.437, 0.211, '好瓜'],
 
             ['乌黑', '稍蜷', '沉闷', '稍糊', '稍凹', '硬滑', 0.666, 0.091, '坏瓜'],
             ['青绿', '硬挺', '清脆', '清晰', '平坦', '软粘', 0.243, 0.267, '坏瓜'],
             ['浅白', '硬挺', '清脆', '模糊', '平坦', '硬滑', 0.245, 0.057, '坏瓜'],
             ['浅白', '蜷缩', '浊响', '模糊', '平坦', '软粘', 0.343, 0.099, '坏瓜'],
             ['青绿', '稍蜷', '浊响', '稍糊', '凹陷', '硬滑', 0.639, 0.161, '坏瓜'],  
             ['浅白', '稍蜷', '沉闷', '稍糊', '凹陷', '硬滑', 0.657, 0.198, '坏瓜'],
             ['乌黑', '稍蜷', '浊响', '清晰', '稍凹', '软粘', 0.360, 0.370, '坏瓜'],
             ['浅白', '蜷缩', '浊响', '模糊', '平坦', '硬滑', 0.593, 0.042, '坏瓜'],
             ['青绿', '蜷缩', '沉闷', '稍糊', '稍凹', '硬滑', 0.719, 0.103, '坏瓜']]
    testSet= ['青绿', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', 0.697, 0.460] # 待测集
    labels = ['色泽', '根蒂', '敲声', '纹理', '脐部', '触感', '密度', '含糖率'] # 特征
    
    return dataSet, testSet, labels

dataSet：训练集；
testSet：待测集；
labels：样本所具有的特征的名称；

（3）计算连续属性的均值和标准差

#? 计算(不同类别中指定连续特征的)均值、标准差
def mean_std(feature, cla):
    dataSet, testSet, labels = loadDataSet()
    lst = [item[labels.index(feature)] for item in dataSet if item[-1]==cla]    # 类别为cla中指定特征feature组成的列表
    mean = round(np.mean(lst), 3)   # 均值
    std = round(np.std(lst), 3)     # 标准差
 
    return mean, std

feature：传入指定将要计算其均值的标准差的特征名称；
cla：传入条件概率的条件，计算指定分类cla下该特征的条件概率；
函数返回计算结果：均值mean、标准差std；

（4）计算先验概率

#? 计算先验概率P(c)
def prior():
    dataSet = loadDataSet()[0]  # 载入数据集
    countG = 0  # 初始化好瓜数量
    countB = 0  # 初始化坏瓜数量
    countAll = len(dataSet)
 
    for item in dataSet:    # 统计好瓜个数
        if item[-1] == "好瓜":
            countG += 1
    for item in dataSet:    # 统计坏瓜个数
        if item[-1] == "坏瓜":
            countB += 1
    
    # 计算先验概率P(c)
    P_G = round(countG/countAll, 3)
    P_B = round(countB/countAll, 3)
 
    return P_G,P_B

countG：统计训练集中好瓜的数量；
countB：统计训练集中坏瓜的数量；
countAll：训练集中所有样本的数量；
P_G：好瓜的先验概率；
P_B：坏瓜的先验概率；
函数返回计算出的先验概率P_G、P_B；

（5）计算离散属性的条件概率

#? 计算离散属性的条件概率P(xi|c)
def P(index, cla):
    dataSet, testSet, labels = loadDataSet()    # 载入数据集
    countG = 0  # 初始化好瓜数量
    countB = 0  # 初始化坏瓜数量
 
    for item in dataSet:    # 统计好瓜个数
        if item[-1] == "好瓜":
            countG += 1
    for item in dataSet:    # 统计坏瓜个数
        if item[-1] == "坏瓜":
            countB += 1
    
    lst = [item for item in dataSet if (item[-1] == cla) & (item[index] == testSet[index])] # lst为cla类中第index个属性上取值为xi的样本组成的集合
    P = round(len(lst)/(countG if cla=="好瓜" else countB), 3)  # 计算条件概率
 
    return P

index：用于根据待测集样本中特征值的索引位置在训练集中样本的对应索引位置上进行遍历；
cla：用于在训练集中限定样本的类别，便于计算离散属性各特征的条件概率；
countG：统计训练集中好瓜的数量；
countB：统计训练集中坏瓜的数量；
lst：为cla类别中第index个属性上取值为xi的样本组成的集合；
P：离散属性的条件概率；
函数返回计算出的条件概率P；

（6）计算连续属性的条件概率

#? 计算连续属性的条件概率p(xi|c)
def p():
    dataSet, testSet, labels = loadDataSet()    # 载入数据集
    denG_mean, denG_std = mean_std("密度", "好瓜")      # 好瓜密度的均值、标准差
    denB_mean, denB_std = mean_std("密度", "坏瓜")      # 坏瓜密度的均值、标准差
    sugG_mean, sugG_std = mean_std("含糖率", "好瓜")    # 好瓜含糖率的均值、标准差
    sugB_mean, sugB_std = mean_std("含糖率", "坏瓜")    # 坏瓜含糖率的均值、标准差
    # p(密度|好瓜)
    p_density_G = (1/(math.sqrt(2*math.pi)*denG_std))*np.exp(-(((testSet[labels.index("密度")]-denG_mean)**2)/(2*(denG_std**2))))
    p_density_G = round(p_density_G, 3)
    # p(密度|坏瓜)
    p_density_B = (1/(math.sqrt(2*math.pi)*denB_std))*np.exp(-(((testSet[labels.index("密度")]-denB_mean)**2)/(2*(denB_std**2))))
    p_density_B = round(p_density_B, 3)
    # p(含糖率|好瓜)
    p_sugar_G = (1/(math.sqrt(2*math.pi)*sugG_std))*np.exp(-(((testSet[labels.index("含糖率")]-sugG_mean)**2)/(2*(sugG_std**2))))
    p_sugar_G = round(p_sugar_G, 3)
    # p(含糖率|坏瓜)
    p_sugar_B = (1/(math.sqrt(2*math.pi)*sugB_std))*np.exp(-(((testSet[labels.index("含糖率")]-sugB_mean)**2)/(2*(sugB_std**2))))
    p_sugar_B = round(p_sugar_B, 3)
 
    return p_density_G, p_density_B, p_sugar_G, p_sugar_B

denG_mean：好瓜密度的均值；
denG_std：好瓜密度的标准差；
denB_mean：坏瓜密度的均值；
denB_std：坏瓜密度的标准差；
sugG_mean：好瓜含糖率的均值；
sugG_std：好瓜含糖率的标准差；
sugB_mean：坏瓜含糖率的均值；
sugB_std：坏瓜含糖率的标准差；
p_density_G：好瓜条件下对于密度这一特征的条件概率；
p_density_B：坏瓜条件下对于密度这一特征的条件概率；
p_sugar_G：好瓜条件下对于含糖率这一特征的条件概率；
p_sugar_B：坏瓜条件下对于含糖率这一特征的条件概率；
函数返回连续属性的条件概率；

（7）计算后验概率

#? 预测后验概率P(c|xi)
def bayes():
    #? 计算类先验概率
    P_G, P_B = prior()
    #? 计算离散属性的条件概率
    P0_G = P(0, "好瓜") # P(青绿|好瓜)
    P0_B = P(0, "坏瓜") # P(青绿|坏瓜)
    P1_G = P(1, "好瓜") # P(蜷缩|好瓜)
    P1_B = P(1, "坏瓜") # P(蜷缩|好瓜)
    P2_G = P(2, "好瓜") # P(浊响|好瓜)
    P2_B = P(2, "坏瓜") # P(浊响|好瓜)
    P3_G = P(3, "好瓜") # P(清晰|好瓜)
    P3_B = P(3, "坏瓜") # P(清晰|好瓜)
    P4_G = P(4, "好瓜") # P(凹陷|好瓜)
    P4_B = P(4, "坏瓜") # P(凹陷|好瓜)
    P5_G = P(5, "好瓜") # P(硬滑|好瓜)
    P5_B = P(5, "坏瓜") # P(硬滑|好瓜)
    #? 计算连续属性的条件概率
    p_density_G, p_density_B, p_sugar_G, p_sugar_B = p()
 
    #? 计算后验概率
    isGood = P_G * P0_G * P1_G * P2_G * P3_G * P4_G * P5_G * p_density_G * p_sugar_G    # 计算是好瓜的后验概率
    isBad = P_B * P0_B * P1_B * P2_B * P3_B * P4_B * P5_B * p_density_B * p_sugar_B     # 计算是坏瓜的后验概率
 
    return isGood,isBad

调用prior()函数计算先验概率；
调用P()函数计算离散属性的条件概率；
调用p()函数计算连续属性的条件概率；
isGood：好瓜的后验概率；
isBad：坏瓜的后验概率；
函数返回后验概率的计算结果isGood、isBad；

（8）主函数调用上述函数模块

if __name__=='__main__':
    dataSet, testSet, labels = loadDataSet()
    testSet = [testSet]
    df = pd.DataFrame(testSet, columns=labels, index=[1])
    print("=======================待测样本========================")
    print(f"待测集:\n{df}")
 
    isGood, isBad = bayes()
    print("=======================后验概率========================")
    print("后验概率:")
    print(f"P(好瓜|xi) = {isGood}")
    print(f"P(好瓜|xi) = {isBad}")
    print("=======================预测结果========================")
    print("predict ---> 好瓜" if (isGood > isBad) else "predict ---> 坏瓜")

输出为：

从上图的终端输出结果可以看到待测样本的各个属性值，然后可以看到后验概率的计算结果，最后是预测结果，此样本的预测结果为“好瓜”。

此训练集与待测样本是“朴素贝叶斯西瓜集分类案例”的数据，通过比较最终的两个预测结果一致，也可表明朴素贝叶斯分类器编写代码基本正确。

完整代码

#! 朴素贝叶斯分类器_西瓜集分类
import numpy as np
import math
import pandas as pd
 
#? 加载数据集
def loadDataSet():
    dataSet=[['青绿', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', 0.697, 0.460, '好瓜'],
             ['乌黑', '蜷缩', '沉闷', '清晰', '凹陷', '硬滑', 0.774, 0.376, '好瓜'],
             ['乌黑', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', 0.634, 0.264, '好瓜'],
             ['青绿', '蜷缩', '沉闷', '清晰', '凹陷', '硬滑', 0.608, 0.318, '好瓜'],
             ['浅白', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', 0.556, 0.215, '好瓜'],            
             ['青绿', '稍蜷', '浊响', '清晰', '稍凹', '软粘', 0.403, 0.237, '好瓜'],               
             ['乌黑', '稍蜷', '浊响', '稍糊', '稍凹', '软粘', 0.481, 0.149, '好瓜'],                
             ['乌黑', '稍蜷', '浊响', '清晰', '稍凹', '硬滑', 0.437, 0.211, '好瓜'],
 
             ['乌黑', '稍蜷', '沉闷', '稍糊', '稍凹', '硬滑', 0.666, 0.091, '坏瓜'],
             ['青绿', '硬挺', '清脆', '清晰', '平坦', '软粘', 0.243, 0.267, '坏瓜'],
             ['浅白', '硬挺', '清脆', '模糊', '平坦', '硬滑', 0.245, 0.057, '坏瓜'],
             ['浅白', '蜷缩', '浊响', '模糊', '平坦', '软粘', 0.343, 0.099, '坏瓜'],
             ['青绿', '稍蜷', '浊响', '稍糊', '凹陷', '硬滑', 0.639, 0.161, '坏瓜'],  
             ['浅白', '稍蜷', '沉闷', '稍糊', '凹陷', '硬滑', 0.657, 0.198, '坏瓜'],
             ['乌黑', '稍蜷', '浊响', '清晰', '稍凹', '软粘', 0.360, 0.370, '坏瓜'],
             ['浅白', '蜷缩', '浊响', '模糊', '平坦', '硬滑', 0.593, 0.042, '坏瓜'],
             ['青绿', '蜷缩', '沉闷', '稍糊', '稍凹', '硬滑', 0.719, 0.103, '坏瓜']]
    testSet= ['青绿', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', 0.697, 0.460] # 待测集
    labels = ['色泽', '根蒂', '敲声', '纹理', '脐部', '触感', '密度', '含糖率'] # 特征
    
    return dataSet, testSet, labels
 
#? 计算(不同类别中指定连续特征的)均值、标准差
def mean_std(feature, cla):
    dataSet, testSet, labels = loadDataSet()
    # 类别为cla中指定特征feature组成的列表
    lst = [item[labels.index(feature)] for item in dataSet if item[-1]==cla]    
    mean = round(np.mean(lst), 3)   # 均值
    std = round(np.std(lst), 3)     # 标准差
 
    return mean, std
 
#? 计算先验概率P(c)
def prior():
    dataSet = loadDataSet()[0]  # 载入数据集
    countG = 0  # 初始化好瓜数量
    countB = 0  # 初始化坏瓜数量
    countAll = len(dataSet)
 
    for item in dataSet:    # 统计好瓜个数
        if item[-1] == "好瓜":
            countG += 1
    for item in dataSet:    # 统计坏瓜个数
        if item[-1] == "坏瓜":
            countB += 1
    
    # 计算先验概率P(c)
    P_G = round(countG/countAll, 3)
    P_B = round(countB/countAll, 3)
 
    return P_G,P_B
 
#? 计算离散属性的条件概率P(xi|c)
def P(index, cla):
    dataSet, testSet, labels = loadDataSet()    # 载入数据集
    countG = 0  # 初始化好瓜数量
    countB = 0  # 初始化坏瓜数量
 
    for item in dataSet:    # 统计好瓜个数
        if item[-1] == "好瓜":
            countG += 1
    for item in dataSet:    # 统计坏瓜个数
        if item[-1] == "坏瓜":
            countB += 1
    
    lst = [item for item in dataSet if (item[-1] == cla) & (item[index] == testSet[index])] # lst为cla类中第index个属性上取值为xi的样本组成的集合
    P = round(len(lst)/(countG if cla=="好瓜" else countB), 3)  # 计算条件概率
 
    return P
 
#? 计算连续属性的条件概率p(xi|c)
def p():
    dataSet, testSet, labels = loadDataSet()    # 载入数据集
    denG_mean, denG_std = mean_std("密度", "好瓜")      # 好瓜密度的均值、标准差
    denB_mean, denB_std = mean_std("密度", "坏瓜")      # 坏瓜密度的均值、标准差
    sugG_mean, sugG_std = mean_std("含糖率", "好瓜")    # 好瓜含糖率的均值、标准差
    sugB_mean, sugB_std = mean_std("含糖率", "坏瓜")    # 坏瓜含糖率的均值、标准差
    # p(密度|好瓜)
    p_density_G = (1/(math.sqrt(2*math.pi)*denG_std))*np.exp(-(((testSet[labels.index("密度")]-denG_mean)**2)/(2*(denG_std**2))))
    p_density_G = round(p_density_G, 3)
    # p(密度|坏瓜)
    p_density_B = (1/(math.sqrt(2*math.pi)*denB_std))*np.exp(-(((testSet[labels.index("密度")]-denB_mean)**2)/(2*(denB_std**2))))
    p_density_B = round(p_density_B, 3)
    # p(含糖率|好瓜)
    p_sugar_G = (1/(math.sqrt(2*math.pi)*sugG_std))*np.exp(-(((testSet[labels.index("含糖率")]-sugG_mean)**2)/(2*(sugG_std**2))))
    p_sugar_G = round(p_sugar_G, 3)
    # p(含糖率|坏瓜)
    p_sugar_B = (1/(math.sqrt(2*math.pi)*sugB_std))*np.exp(-(((testSet[labels.index("含糖率")]-sugB_mean)**2)/(2*(sugB_std**2))))
    p_sugar_B = round(p_sugar_B, 3)
 
    return p_density_G, p_density_B, p_sugar_G, p_sugar_B
 
#? 预测后验概率P(c|xi)
def bayes():
    #? 计算类先验概率
    P_G, P_B = prior()
    #? 计算离散属性的条件概率
    P0_G = P(0, "好瓜") # P(青绿|好瓜)
    P0_B = P(0, "坏瓜") # P(青绿|坏瓜)
    P1_G = P(1, "好瓜") # P(蜷缩|好瓜)
    P1_B = P(1, "坏瓜") # P(蜷缩|好瓜)
    P2_G = P(2, "好瓜") # P(浊响|好瓜)
    P2_B = P(2, "坏瓜") # P(浊响|好瓜)
    P3_G = P(3, "好瓜") # P(清晰|好瓜)
    P3_B = P(3, "坏瓜") # P(清晰|好瓜)
    P4_G = P(4, "好瓜") # P(凹陷|好瓜)
    P4_B = P(4, "坏瓜") # P(凹陷|好瓜)
    P5_G = P(5, "好瓜") # P(硬滑|好瓜)
    P5_B = P(5, "坏瓜") # P(硬滑|好瓜)
    #? 计算连续属性的条件概率
    p_density_G, p_density_B, p_sugar_G, p_sugar_B = p()
 
    #? 计算后验概率
    isGood = P_G * P0_G * P1_G * P2_G * P3_G * P4_G * P5_G * p_density_G * p_sugar_G    # 计算是好瓜的后验概率
    isBad = P_B * P0_B * P1_B * P2_B * P3_B * P4_B * P5_B * p_density_B * p_sugar_B     # 计算是坏瓜的后验概率
    '''print(P_G)
    print(P_B)
    print(P0_G)
    print(P0_B)
    print(P1_G)
    print(P1_B)
    print(P2_G)
    print(P2_B)
    print(P3_G)
    print(P3_B)
    print(P4_G)
    print(P4_B)
    print(P5_G)
    print(P5_B)
    print(p_density_G)
    print(p_density_B)
    print(p_sugar_G)
    print(p_sugar_B)'''
 
    return isGood,isBad
 
if __name__=='__main__':
    # 
    dataSet, testSet, labels = loadDataSet()
    testSet = [testSet]
    df = pd.DataFrame(testSet, columns=labels, index=[1])
    print("=======================待测样本========================")
    print(f"待测集:\n{df}")
 
    isGood, isBad = bayes()
    print("=======================后验概率========================")
    print("后验概率:")
    print(f"P(好瓜|xi) = {isGood}")
    print(f"P(好瓜|xi) = {isBad}")
    print("=======================预测结果========================")
    print("predict ---> 好瓜" if (isGood > isBad) else "predict ---> 坏瓜")

使用sklearn

在scikit-learn中，一共有3个朴素贝叶斯的分类算法类。分别是GaussianNB，MultinomialNB和BernoulliNB。其中GaussianNB就是先验为高斯分布的朴素贝叶斯，MultinomialNB就是先验为多项式分布的朴素贝叶斯，而BernoulliNB就是先验为伯努利分布的朴素贝叶斯。

GaussianNB实现

# 加载数据集
print("=======================加载数据集========================")
from sklearn import datasets
iris = datasets.load_iris()
print("---iris.data[0:5],iris.target[0:5]---")
print(iris.data[0:5],iris.target[0:5])
print("---iris.data[145:],iris.target[145:]---")
print(iris.data[145:],iris.target[145:])
# 分割数据集
print("=======================分割数据集========================")
from sklearn.model_selection import train_test_split
# iris.data是特征值 iris.target是标签值 test_size表示测试集的比例 random_state表示随机数种子
# 随机数种子相同，每次生成的随机数也相同
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=0)
print("---X_train,y_train---")
print(len(X_train),len(y_train))
print(X_train[0:5],y_train[0:5])
print("---X_test,y_test---")
print(len(X_test),len(y_test))
print(X_test[0:5],y_test[0:5])

# 构建模型
print("=======================构建模型========================")
from sklearn.naive_bayes import GaussianNB
clf = GaussianNB()
# 训练模型
print("=======================训练模型========================")
clf.fit(X_train, y_train)
# 验证模型
print("=======================手写评价函数 验证模型========================")
y_train_pred = clf.predict(X_train)
print("---y_train_pred---")
print(y_train_pred)
print("---y_train---")
print(y_train)
# 计算准确率的函数
def accuracy(y_train, y_train_pred):
    c_num=0
    for i in range(len(y_train)):
        if y_train[i] != y_train_pred[i]:
            print("第",i,"个样本预测错误")
        else:
            c_num+=1
    # 返回总样本数，正确样本数，准确率
    return len(X_train),c_num,(c_num)/len(X_train)
total_len,correct_len,acc=accuracy(y_train, y_train_pred)

print("高斯朴素贝叶斯，样本总数： %d 正确样本数 : %d" % (total_len,correct_len))
# 输出准确率
print("准确率",acc)

print("=======================使用模型的score评价模型========================")
# 使用sklearn计算准确率
print("clf.score(X_train, y_train)--> ",clf.score(X_train, y_train))

# 预测
print("=======================使用metrics模块 评价模型========================")
y_pred = clf.predict(X_test)
print("---y_pred---")
print(y_pred)
print("---y_test---")
print(y_test)
# 导入评价指标
from sklearn import metrics
# 计算准确率
print("=======================计算准确率========================")
print("GaussianNB 准确率：",metrics.accuracy_score(y_test, y_pred))


# 保存模型
print("=======================保存模型========================")
import pickle
# 保存模型
with open('bys_model.pkl', 'wb') as f:
    pickle.dump(clf, f)
# 采用joblib方式保存模型
import joblib
joblib.dump(clf, 'bys_model2.pkl')


# 加载模型
print("=======================加载模型========================")
with open('bys_model.pkl', 'rb') as f:
    clf2 = pickle.load(f)
# 采用joblib方式加载模型
joblib_clf2 = joblib.load('bys_model2.pkl')

# 输出模型的内容
print("=======================输出模型的内容========================")
print("clf2--->",clf2)
print("joblib_clf2--->",joblib_clf2)

# 预测
print("=======================预测========================")
y_pred2 = clf2.predict(X_test)
joblib_clf2_y_pred2 = joblib_clf2.predict(X_test)
print("=======================计算加载模型准确率========================")
print("pickle模型准确率：",metrics.accuracy_score(y_test, y_pred2))
print("joblib_clf2模型准确率：",metrics.accuracy_score(y_test, joblib_clf2_y_pred2))

输出为：

MultinomialNB实现

# 构建模型
print("=======================构建模型========================")
from sklearn.naive_bayes import GaussianNB,MultinomialNB,BernoulliNB
# clf = GaussianNB()
clf = MultinomialNB()
# clf = BernoulliNB()

BernoulliNB 伯努利分布

# 构建模型
print("=======================构建模型========================")
from sklearn.naive_bayes import GaussianNB,MultinomialNB,BernoulliNB
# clf = GaussianNB()
# clf = MultinomialNB()
clf = BernoulliNB()

输出为：

确定方向过程

针对完全没有基础的同学们
1.确定机器学习的应用领域有哪些
2.查找机器学习的算法应用有哪些
3.确定想要研究的领域极其对应的算法
4.通过招聘网站和论文等确定具体的技术
5.了解业务流程，查找数据
6.复现经典算法
7.持续优化，并尝试与对应企业人员沟通心得
8.企业给出反馈