​​​​​​​【机器学习】朴素贝叶斯（Naive Bayes）_朴素贝叶斯数据集

# 导入包
import pandas as pd
from sklearn.naive_bayes import GaussianNB
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn import datasets
 
# 导入数据集
iris = datasets.load_iris()
 
# 切分数据集,将数据的内容余目标切分成训练集和测试集
Xtrain, Xtest, ytrain, ytest = train_test_split(iris.data,
                                                iris.target,
                                                random_state=12)
# 建模
clf = GaussianNB()
clf.fit(Xtrain, ytrain)
# 在测试集上执行预测，proba导出的是每个样本属于某类的概率
pre_result=clf.predict(Xtest)   # 预测结果
pro_result=clf.predict_proba(Xtest) # 预测的每一类的百分比
# 测试准确率
accuracy_value=accuracy_score(ytest, pre_result)
# 打印输出结果
print(ytest)        # 测试集的正确值
print(pre_result)   # 测试集的预测值
print(pro_result)   # 测试集的计算结果 每一类的可能性百分比
print(accuracy_value)   # 最后预测准确率

"""
函数功能：创建实验数据集
参数说明：无参数
返回：
    postingList：切分好的样本词条
    classVec：类标签向量
"""
 
 
def loadDataSet():
    dataSet = [['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],
               ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
               ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
               ['stop', 'posting', 'stupid', 'worthless', 'garbage'],
               ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
               ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]  # 切分好的词条
    classVec = [0, 1, 0, 1, 0, 1]  # 类别标签向量，1代表侮辱性词汇，0代表非侮辱性词汇
    return dataSet, classVec

"""
函数功能：生成词汇表：将切分的样本词条整理成词汇表（不重复）
参数说明：
    dataSet：切分好的样本词条
返回：
    vocabList：不重复的词汇表
"""
 
 
def createVocabList(dataSet):
    vocabSet = set()  # 创建一个空的集合
    for doc in dataSet:  # 遍历dataSet中的每一条言论
        vocabSet = vocabSet | set(doc)  # 取并集
        vocabList = list(vocabSet)
    return vocabList

"""
函数功能：根据vocabList词汇表，将inputSet向量化，向量的每个元素为1或0
参数说明：
    vocabList：词汇表
    inputSet：切分好的词条列表中的一条
返回：
    returnVec：文档向量,词集模型
"""
 
 
def setOfWords2Vec(vocabList, inputSet):
    returnVec = [0] * len(vocabList)  # 创建一个其中所含元素都为0的向量
    for word in inputSet:  # 遍历每个词条
        if word in vocabList:  # 如果词条存在于词汇表中，则变为1
            returnVec[vocabList.index(word)] = 1
        else:
            print(f" {word} is not in my Vocabulary!")
    return returnVec  # 返回文档向量

"""
函数功能：生成训练集向量列表
参数说明：
dataSet：切分好的样本词条
返回：
trainMat：所有的词条向量组成的列表
"""
 
 
def get_trainMat(dataSet):
    trainMat = []  # 初始化向量列表
    vocabList = createVocabList(dataSet)  # 生成词汇表
    for inputSet in dataSet:  # 遍历样本词条中的每一条样本
        returnVec = setOfWords2Vec(vocabList, inputSet)  # 将当前词条向量化
        trainMat.append(returnVec)  # 追加到向量列表中
    return trainMat

"""
函数功能：朴素贝叶斯分类器训练函数
参数说明：
    trainMat：训练文档矩阵
    classVec：训练类别标签向量
返回：
    p0V：非侮辱类的条件概率数组
    p1V：侮辱类的条件概率数组
    pAb：文档属于侮辱类的概率
"""
 
 
def trainNB(trainMat, classVec):
    n = len(trainMat)  # 计算训练的文档数目
    m = len(trainMat[0])  # 计算每篇文档的词条数
    pAb = sum(classVec) / n  # 文档属于侮辱类的概率
    p0Num = np.zeros(m)  # 词条出现数初始化为0
    p1Num = np.zeros(m)  # 词条出现数初始化为0
    p0Denom = 0  # 分母初始化为0
    p1Denom = 0  # 分母初始化为0
    for i in range(n):  # 遍历每一个文档
        if classVec[i] == 1:  # 统计属于侮辱类的条件概率所需的数据
            p1Num += trainMat[i]
            p1Denom += sum(trainMat[i])
        else:  # 统计属于非侮辱类的条件概率所需的数据
            p0Num += trainMat[i]
            p0Denom += sum(trainMat[i])
    p1V = p1Num / p1Denom
    p0V = p0Num / p0Denom
    return p0V, p1V, pAb  # 返回属于非侮辱类,侮辱类和文档属于侮辱类的概率

"""
函数功能：朴素贝叶斯分类器分类函数
参数说明：
vec2Classify：待分类的词条数组
p0V：非侮辱类的条件概率数组
p1V：侮辱类的条件概率数组
pAb：文档属于侮辱类的概率
返回：
0：属于非侮辱类
1：属于侮辱类
"""
 
 
def classifyNB(vec2Classify, p0V, p1V, pAb):
    p1 = reduce(lambda x, y: x * y, vec2Classify * p1V) * pAb  # 对应元素相乘
    p0 = reduce(lambda x, y: x * y, vec2Classify * p0V) * (1 - pAb)
    print('p0:', p0)
    print('p1:', p1)
    if p1 > p0:
        return 1
    else:
        return 0

"""
函数功能：朴素贝叶斯测试函数
参数说明：
testVec：测试样本
返回：测试样本的类别
"""
 
 
def testingNB(testVec):
    dataSet, classVec = loadDataSet()  # 创建实验样本
    vocabList = createVocabList(dataSet)  # 创建词汇表
    trainMat = get_trainMat(dataSet)  # 将实验样本向量化
    p0V, p1V, pAb = trainNB(trainMat, classVec)  # 训练朴素贝叶斯分类器
    thisone = setOfWords2Vec(vocabList, testVec)  # 测试样本向量化
    if classifyNB(thisone, p0V, p1V, pAb):
        print(testVec, '属于侮辱类')  # 执行分类并打印分类结果
    else:
        print(testVec, '属于非侮辱类')  # 执行分类并打印分类结果

# 测试样本1
testVec1 = ['love', 'my', 'dalmation']
testingNB(testVec1)
# 测试样本2
testVec2 = ['stupid', 'garbage']
testingNB(testVec2)

# 使用拉普拉斯平滑处理的
def trainNB(trainMat,classVec):
    n = len(trainMat) #计算训练的文档数目
    m = len(trainMat[0]) #计算每篇文档的词条数
    pAb = sum(classVec)/n #文档属于侮辱类的概率
    p0Num = np.ones(m) #词条出现数初始化为1
    p1Num = np.ones(m) #词条出现数初始化为1
    p0Denom = 2 #分母初始化为2
    p1Denom = 2 #分母初始化为2
    for i in range(n): #遍历每一个文档
        if classVec[i] == 1: #统计属于侮辱类的条件概率所需的数据
            p1Num += trainMat[i]
            p1Denom += sum(trainMat[i])
        else: #统计属于非侮辱类的条件概率所需的数据
            p0Num += trainMat[i]
            p0Denom += sum(trainMat[i])
    p1V = np.log(p1Num/p1Denom)
    p0V = np.log(p0Num/p0Denom)
    return p0V,p1V,pAb #返回属于非侮辱类,侮辱类和文档属于侮辱类的概率
 
# 使用拉普拉斯平滑处理的
def classifyNB(vec2Classify, p0V, p1V, pAb):
    p1 = sum(vec2Classify * p1V) + np.log(pAb)  # 对应元素相乘
    p0 = sum(vec2Classify * p0V) + np.log(1 - pAb)  # 对应元素相乘
    if p1 > p0:
        return 1
    else:
        return 0