机器学习-朴素贝叶斯。_收集数据集的数据说明书

前言：

朴素贝叶斯是经典的机器学习算法之一，也是为数不多的基于概率论的分类算法。朴素贝叶斯原理简单，也很容易实现，多用于文本分类，比如垃圾邮件过滤。

1.算法思想——基于概率的预测

决策树算法中提到朴素贝叶斯分类模型是应用最为广泛的分类模型之一，朴素贝叶斯分类是贝叶斯分类器的一种，贝叶斯分类算法是统计学的一种分类方法，利用概率统计知识进行分类，其分类原理就是利用贝叶斯公式根据某对象的先验概率计算出其后验概率（即该对象属于某一类的概率），然后选择具有最大后验概率的类作为该对象所属的类。目前研究较多的贝叶斯分类器主要有四种分别是：朴素贝叶斯分类、TAN(tree augmented Bayes network)算法、BAN(BN Augmented Naive Bayes）分类和GBN（General Bayesian Network）。本文重点详细阐述朴素贝叶斯分类的原理，通过Python实现了该算法，并介绍了朴素贝叶斯分类的一个应用--垃圾邮件检测。

朴素贝叶斯的思想基础是这样的：根据贝叶斯公式，计算待分类项x出现的条件下各个类别（预先已知的几个类别）出现的概率P(yi|x)，最后哪个概率值最大，就判定该待分类项属于哪个类别。训练数据的目的就在于获取样本各个特征在各个分类下的先验概率。之所以称之为“朴素”，是因为贝叶斯分类只做最原始、最简单的假设--1,所有的特征之间是统计独立的;2,所有的特征地位相同。那么假设某样本x有a1,...,aM个属性，那么有：

P(x)=P(a1,...,aM) = P(a1)*...*P(aM)

朴素贝叶斯分类发源于古典数学理论，有着坚实的数学基础，以及稳定的分类效率，其优点是算法简单、所需估计参数很少、对缺失数据不太敏感。理论上，朴素贝叶斯分类与其他分类方法相比具有最小的误差率，但实际上并非总是如此，因为朴素贝叶斯分类假设样本各个特征之间相互独立，这个假设在实际应用中往往是不成立的，从而影响分类正确性。因此，当样本特征个数较多或者特征之间相关性较大时，朴素贝叶斯分类效率比不上决策树模型；当各特征相关性较小时，朴素贝叶斯分类性能最为良好。总的来说，朴素贝叶斯分类算法简单有效，对两类、多类问题都适用。另外朴素贝叶斯的计算过程类条件概率等计算彼此是独立的，因此特别适于分布式计算。

1.贝叶斯定理

贝叶斯定理是关于随机事件A和B的条件概率（或边缘概率）的一则定理。

其中P(A|B)是在B发生的情况下A发生的可能性。

在贝叶斯定理中，每个名词都有约定俗成的名称：

P(A)是A的先验概率或边缘概率。之所以称为"先验"是因为它不考虑任何B方面的因素。

P(A|B)是已知B发生后A的条件概率，也由于得自B的取值而被称作A的后验概率。

P(B|A)是已知A发生后B的条件概率，也由于得自A的取值而被称作B的后验概率。

P(B)是B的先验概率或边缘概率，也作标准化常量（normalizing constant）.

2，朴素贝叶斯分类的概率论原理
2.1 贝叶斯分类概率论描述
用概率论来表达朴素贝叶斯分类的过程就是：

1、是一个待分类的项，ai为x的特征属性（地位相同、相互独立），共m个。

2、有类别集合。

3、计算。

4、如果，则。

显然，问题的关键在于第三步-求出各分类项的后验概率，用到的就是贝叶斯公式。

则根据贝叶斯定理有如下推导：

分母对于所有类别来说都是为常数，因此只需计算分子即可。又因为各个特征具有相同的地位且各自出现的概率相互独立，所以有：

上式中，P(aj|yi)是关键，其含义就是样本各个特征在各个分类下的条件概率，计算各个划分的条件概率是朴素贝叶斯分类的关键性步骤，也就是数据训练阶段的任务所在。至于样本每个特征的概率分布则可能是离散的，也可能是连续的。

2.2 先验条件概率的计算方法
由上文看出，计算各个划分的条件概率P(a|y)是朴素贝叶斯分类的关键性步骤，下面说明特征属性为离散分布或者连续分布的计算、处理方法。

1，离散分布-当特征属性为离散值时，只要统计训练样本中各个划分在每个类别中出现的频率即可用来估计P(a|y)。

由于贝叶斯分类需要计算多个特征值概率以获得事物项属于某一类的概率，若某一特征值的概率为0则会使整个概率乘积变为0（称为数据稀疏），这破坏了各特征值地位相同的假设条件，使分类准确率大大降低。因此为了降低破坏率，离散分布必须进行校准-如Laplace校准：每个类别下所有特征划分的计数都加1，训练样本集数量足够大，因此并不会对结果产生影响，但却解决了上述概率为0的尴尬局面；另外从运算效率上，加法也比乘法提高了一个量级。

数据稀疏是机器学习中很大的问题，比拉普拉斯平滑更好的解决数据稀疏的方法是：通过聚类将未出现的词找出系统相关词，根据相关词的概率求一个平均值。如果：系统有“苹果”，“葡萄”等词，但是没有“榴莲”，我们可以根据“苹果”，“葡萄”等平均值作为“榴莲”的概率，这样更合理。

2，连续分布-当特征属性为连续值时，通常假定其值服从高斯分布（正态分布）。即：

 

对于连续分布的样本特征的训练就是计算其均值和方差。

朴素贝叶斯实现垃圾邮件分类的步骤

（1）收集数据：提供文本文件。

（2）准备数据：将文本文件解析成词条向量。

（3）分析数据：检查词条确保解析的正确性。

（4）训练算法：计算不同的独立特征的条件概率。

（5）测试算法：计算错误率。

（6）使用算法：构建一个完整的程序对一组文档进行分类。

收集数据集

ham文件夹下的txt文件为正常邮件；

spam文件下的txt文件为垃圾邮件；

 

 

训练集里面正常邮件normal和垃圾邮件spam各有24封，利用这些数据训练出模型并对两份待分类邮件进行分类。

准备数据：

"""
函数说明:将切分的实验样本词条整理成不重复的词条列表，也就是词汇表
Parameters:
    dataSet - 整理的样本数据集
Returns:
    vocabSet - 返回不重复的词条列表，也就是词汇表
"""
def createVocabList(dataSet):
    vocabSet = set([])  # 创建一个空的不重复列表
    for document in dataSet:
        vocabSet = vocabSet | set(document)  # 取并集
    return list(vocabSet)

分析数据：

函数说明:根据vocabList词汇表，将inputSet向量化，向量的每个元素为1或0
Parameters:
    vocabList - createVocabList返回的列表
    inputSet - 切分的词条列表
Returns:
    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("the word: %s is not in my Vocabulary!" % word)
    return returnVec        #返回文档向量
 
 
"""
函数说明:根据vocabList词汇表，构建词袋模型
Parameters:
    vocabList - createVocabList返回的列表
    inputSet - 切分的词条列表
Returns:
    returnVec - 文档向量,词袋模型
"""
def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0] * len(vocabList)  # 创建一个其中所含元素都为0的向量
    for word in inputSet:             # 遍历每个词条
        if word in vocabList:         # 如果词条存在于词汇表中，则计数加一
            returnVec[vocabList.index(word)] += 1
    return returnVec  # 返回词袋模型

训练算法：

函数说明:朴素贝叶斯分类器训练函数
Parameters:
    trainMatrix - 训练文档矩阵，即setOfWords2Vec返回的returnVec构成的矩阵
    trainCategory - 训练类别标签向量，即loadDataSet返回的classVec
Returns:
    p0Vect - 正常邮件类的条件概率数组
    p1Vect - 垃圾邮件类的条件概率数组
    pAbusive - 文档属于垃圾邮件类的概率
"""
def trainNB0(trainMatrix, trainCategory):
    numTrainDocs = len(trainMatrix)  # 计算训练的文档数目
    numWords = len(trainMatrix[0])  # 计算每篇文档的词条数
    pAbusive = sum(trainCategory) / float(numTrainDocs)  # 文档属于垃圾邮件类的概率
    p0Num = np.ones(numWords)
    p1Num = np.ones(numWords)  # 创建numpy.ones数组,词条出现数初始化为1,拉普拉斯平滑
    p0Denom = 2.0
    p1Denom = 2.0  # 分母初始化为2 ,拉普拉斯平滑
    for i in range(numTrainDocs):
        if trainCategory[i] == 1:  # 统计属于侮辱类的条件概率所需的数据，即P(w0|1),P(w1|1),P(w2|1)···
            p1Num += trainMatrix[i]
            p1Denom += sum(trainMatrix[i])
        else:  # 统计属于非侮辱类的条件概率所需的数据，即P(w0|0),P(w1|0),P(w2|0)···
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    p1Vect = np.log(p1Num / p1Denom)
    p0Vect = np.log(p0Num / p0Denom)   #取对数，防止下溢出
    return p0Vect, p1Vect, pAbusive  # 返回属于正常邮件类的条件概率数组，属于侮辱垃圾邮件类的条件概率数组，文档属于垃圾邮件类的概率
 

 

 代码运行:

# -*- coding: UTF-8 -*-
import numpy as np
import re
import random
 
 
 
"""
函数说明:将切分的实验样本词条整理成不重复的词条列表，也就是词汇表
Parameters:
    dataSet - 整理的样本数据集
Returns:
    vocabSet - 返回不重复的词条列表，也就是词汇表
"""
def createVocabList(dataSet):
    vocabSet = set([])  # 创建一个空的不重复列表
    for document in dataSet:
        vocabSet = vocabSet | set(document)  # 取并集
    return list(vocabSet)
 
 
"""
函数说明:根据vocabList词汇表，将inputSet向量化，向量的每个元素为1或0
Parameters:
    vocabList - createVocabList返回的列表
    inputSet - 切分的词条列表
Returns:
    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("the word: %s is not in my Vocabulary!" % word)
    return returnVec        #返回文档向量
 
 
"""
函数说明:根据vocabList词汇表，构建词袋模型
Parameters:
    vocabList - createVocabList返回的列表
    inputSet - 切分的词条列表
Returns:
    returnVec - 文档向量,词袋模型
"""
def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0] * len(vocabList)  # 创建一个其中所含元素都为0的向量
    for word in inputSet:             # 遍历每个词条
        if word in vocabList:         # 如果词条存在于词汇表中，则计数加一
            returnVec[vocabList.index(word)] += 1
    return returnVec  # 返回词袋模型
 
 
"""
函数说明:朴素贝叶斯分类器训练函数
Parameters:
    trainMatrix - 训练文档矩阵，即setOfWords2Vec返回的returnVec构成的矩阵
    trainCategory - 训练类别标签向量，即loadDataSet返回的classVec
Returns:
    p0Vect - 正常邮件类的条件概率数组
    p1Vect - 垃圾邮件类的条件概率数组
    pAbusive - 文档属于垃圾邮件类的概率
"""
def trainNB0(trainMatrix, trainCategory):
    numTrainDocs = len(trainMatrix)  # 计算训练的文档数目
    numWords = len(trainMatrix[0])  # 计算每篇文档的词条数
    pAbusive = sum(trainCategory) / float(numTrainDocs)  # 文档属于垃圾邮件类的概率
    p0Num = np.ones(numWords)
    p1Num = np.ones(numWords)  # 创建numpy.ones数组,词条出现数初始化为1,拉普拉斯平滑
    p0Denom = 2.0
    p1Denom = 2.0  # 分母初始化为2 ,拉普拉斯平滑
    for i in range(numTrainDocs):
        if trainCategory[i] == 1:  # 统计属于侮辱类的条件概率所需的数据，即P(w0|1),P(w1|1),P(w2|1)···
            p1Num += trainMatrix[i]
            p1Denom += sum(trainMatrix[i])
        else:  # 统计属于非侮辱类的条件概率所需的数据，即P(w0|0),P(w1|0),P(w2|0)···
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    p1Vect = np.log(p1Num / p1Denom)
    p0Vect = np.log(p0Num / p0Denom)   #取对数，防止下溢出
    return p0Vect, p1Vect, pAbusive  # 返回属于正常邮件类的条件概率数组，属于侮辱垃圾邮件类的条件概率数组，文档属于垃圾邮件类的概率
 
 
"""
函数说明:朴素贝叶斯分类器分类函数
Parameters:
	vec2Classify - 待分类的词条数组
	p0Vec - 正常邮件类的条件概率数组
	p1Vec - 垃圾邮件类的条件概率数组
	pClass1 - 文档属于垃圾邮件的概率
Returns:
	0 - 属于正常邮件类
	1 - 属于垃圾邮件类
"""
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    #p1 = reduce(lambda x, y: x * y, vec2Classify * p1Vec) * pClass1  # 对应元素相乘
    #p0 = reduce(lambda x, y: x * y, vec2Classify * p0Vec) * (1.0 - pClass1)
    p1=sum(vec2Classify*p1Vec)+np.log(pClass1)
    p0=sum(vec2Classify*p0Vec)+np.log(1.0-pClass1)
    if p1 > p0:
        return 1
    else:
        return 0
 
"""
函数说明:接收一个大字符串并将其解析为字符串列表
"""
def textParse(bigString):  # 将字符串转换为字符列表
    listOfTokens = re.split(r'\W*', bigString)  # 将特殊符号作为切分标志进行字符串切分，即非字母、非数字
    return [tok.lower() for tok in listOfTokens if len(tok) > 2]  # 除了单个字母，例如大写的I，其它单词变成小写
 
 
"""
函数说明:测试朴素贝叶斯分类器，使用朴素贝叶斯进行交叉验证
"""
def spamTest():
    docList = []
    classList = []
    fullText = []
    for i in range(1, 26):  # 遍历25个txt文件
        wordList = textParse(open('email/spam/%d.txt' % i, 'r').read())  # 读取每个垃圾邮件，并字符串转换成字符串列表
        docList.append(wordList)
        fullText.append(wordList)
        classList.append(1)  # 标记垃圾邮件，1表示垃圾文件
        wordList = textParse(open('email/ham/%d.txt' % i, 'r').read())  # 读取每个非垃圾邮件，并字符串转换成字符串列表
        docList.append(wordList)
        fullText.append(wordList)
        classList.append(0)  # 标记正常邮件，0表示正常文件
    vocabList = createVocabList(docList)  # 创建词汇表，不重复
    trainingSet = list(range(50))
    testSet = []  # 创建存储训练集的索引值的列表和测试集的索引值的列表
    for i in range(10):  # 从50个邮件中，随机挑选出40个作为训练集,10个做测试集
        randIndex = int(random.uniform(0, len(trainingSet)))  # 随机选取索索引值
        testSet.append(trainingSet[randIndex])  # 添加测试集的索引值
        del (trainingSet[randIndex])  # 在训练集列表中删除添加到测试集的索引值
    trainMat = []
    trainClasses = []  # 创建训练集矩阵和训练集类别标签系向量
    for docIndex in trainingSet:  # 遍历训练集
        trainMat.append(setOfWords2Vec(vocabList, docList[docIndex]))  # 将生成的词集模型添加到训练矩阵中
        trainClasses.append(classList[docIndex])  # 将类别添加到训练集类别标签系向量中
    p0V, p1V, pSpam = trainNB0(np.array(trainMat), np.array(trainClasses))  # 训练朴素贝叶斯模型
    errorCount = 0  # 错误分类计数
    for docIndex in testSet:  # 遍历测试集
        wordVector = setOfWords2Vec(vocabList, docList[docIndex])  # 测试集的词集模型
        if classifyNB(np.array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:  # 如果分类错误
            errorCount += 1  # 错误计数加1
            print("分类错误的测试集：", docList[docIndex])
    print('错误率：%.2f%%' % (float(errorCount) / len(testSet) * 100))
 
 
if __name__ == '__main__':
    spamTest()

运行截图: 

总结：

对待预测样本进行预测，过程简单速度快.
对于多分类问题也同样有效，复杂度也不会有大程度地上升。
在分布独立这个假设成立的情况下，贝叶斯的分类效果很好，会略胜于逻辑回归，我们需要的样本量也更少一点。
对于类别类的输入特征变量，效果非常好。对于数值型变量特征，我们默认它符合正态分布。如果测试集中的一个类别变量特征在训练集里面没有出现过，那么概率就是0，预测功能就将失效，平滑技术可以解决这个问题
朴素贝叶斯中有分布独立的假设前提，但是在现实生活中，这个条件很难满足。