机器学习实战|基于概率论的分类方法：朴素贝叶斯

1 基于贝叶斯决策理论的分类方法

朴素贝叶斯

优点：在数据较少的情况下依然有效，可以处理多类别问题
缺点：对于输入数据的准备方式较为敏感
适用数据类型：标称型数据

贝叶斯决策理论

核心思想：选择具有最高概率的决策

2 条件概率

贝叶斯准则：
$$p(c|x)=\frac{p(x|c)p(c)}{p(x)}$$
理解记忆：
$$p(c|x)p(x)=p(x|c)p(c)=p(x\cap c)$$
x和c同时发生的概率等于x事件发生，在x事件发生的基础上再让c发生；也等于c事件发生，在c事件发生的基础上再让x发生；这两个过程在严格意义上产生的结果是相等的

3 使用条件概率来分类

真正需要比较的是p(c1|x,y)和p(c2|x,y):给定某个由x、y表示的数据点，那么该数据点来自类别c1的概率是多少？来自类别c2的概率是多少

4 使用朴素贝叶斯进行文档分类

朴素贝叶斯分类器的几个假设：
①朴素：只做最原始、最简单的假设
②每个特征同等重要

5 使用python进行文本分类

5.1 准备数据：从文本中构建词向量

def loadDataSet():
    postingList = [['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 postingList, classVec


def createVocabList(dataSet):
    vocabSet = set([])  # 创建一个空集
    for document in dataSet:
        vocabSet = vocabSet | set(document)  # 创建两个集合的合集
    return list(vocabSet)


def setOfWords2Vec(vocaList, inputSet):
    returnVec = [0] * len(vocaList)  # 创建一个其中所含元素都为0的向量
    for word in inputSet:
        if word in vocaList:
            returnVec[vocaList.index(word)] = 1  # index()检测字符串中是否包含子字符串 str
        else:
            print(" %s单词不在我的词汇表中") % word
    return returnVec

listOPosts, listClasses = bayes.loadDataSet()
myVocabList=bayes.createVocabList(listOPosts)
print(bayes.setOfWords2Vec(myVocabList,listOPosts[0]))

5.2 训练算法：从词向量计算概率

伪代码：
计算每个类别中的文档数目
对每篇训练文档：
对每个类别：
如果词条出现在文档中→增加该词条的计数值
增加所有词条的计数值
对每个类别：
对每个词条：
将该词条的数目除以总词条数目得到条件概率
返回每个类别的条件概率

def trainNB0(trainMatrix, trainCategory):  # 输入为文档参数，以及由每篇文档类别标签构成的向量trainCategory
    numTrainDocs = len(trainMatrix)  # 文档个数
    numWords = len(trainMatrix[0])  # 文档词数
    pAbusive = sum(trainCategory) / float(numTrainDocs)  # 文档属于分类1的概率
    # p0Num = zeros(numWords)  # 属于分类0的词向量求和，返回的是一个1行numWords列全是0的数组
    # p1Num = zeros(numWords)
    # p0Denom = 0.0
    # p1Denom = 0.0  # 初始化概率
    p0Num = ones(numWords)  # 修改原因：防止计算多个概率的乘积以获得文档属于某个类别的概率时，其中一个概率值为0，最后乘积也为0；因此可以将所有词的出现次数初始化为1，并将分母初始化为2
    p1Num = ones(numWords)
    p0Denom = 2.0
    p1Denom = 2.0  # 初始化概率
    for i in range(numTrainDocs):
        if trainCategory[i] == 1:
            p1Num += trainMatrix[i]  # 一旦某个词语（侮辱性或正常词语）在某一文档出现，则该词对应的个数+1
            p1Denom += sum(trainMatrix[i])  # 该文档的总词数相应+1;
        else:  # 对两个类别都进行相同的处理
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    # p1Vect = p1Num / p1Denom
    # p0Vect = p0Num / p0Denom
    p1Vect = log(p1Num / p1Denom)  # change to log()原因：防止因为大部分因子很小而造成程序下溢、得到不正确答案
    p0Vect = log(p0Num / p0Denom)
    return p0Vect, p1Vect, pAbusive

listOPosts, listClasses = bayes.loadDataSet()
myVocabList = bayes.createVocabList(listOPosts)
trainMat = []
for postinDoc in listOPosts:
trainMat.append(bayes.setOfWords2Vec(myVocabList, postinDoc))
p0V, p1V, pAb = bayes.trainNB0(trainMat, listClasses)
print(pAb)
print(p0V)
print(p1V)

5.3 测试算法：根据现实情况修改分类器

朴素贝叶斯分类函数：

def testingNB():  # 便利函数，封装所有操作，以节省输入代码的时间
    listOPosts, listClasses = loadDataSet()
    myVocabList = createVocabList(listOPosts)
    trainMat = []
    for postinDoc in listOPosts:
        trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
    p0V, p1V, pAb = trainNB0(array(trainMat), array(listClasses))
    testEntry = ['love', 'my', 'dalmation']
    thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
    print(testEntry, 'classify as:', classifyNB(thisDoc, p0V, p1V, pAb))
    testEntry = ['stupid', 'garbage']
    thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
    print(testEntry, 'classify as:', classifyNB(thisDoc, p0V, p1V, pAb))

5.4 文档词袋模型

注意区分词袋和词集

def bagofWordsVecMN(vocabList, inputSet):  # 朴素贝叶斯词袋模型。词集中每个单词只能出现一次；词袋中每个单词可以出现多次
    returnVec = [0] * len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
    return returnVec

6 示例：使用朴素贝叶斯过滤垃圾邮件

使用通用框架解决过滤垃圾邮件问题：

收集数据：提供文本文件
准备数据：将文本文件解析成词条向量
分析数据：检查词条确保解析的正确性
训练算法：使用之前建立的trainNB0()函数
测试算法：使用classifyNB(),并且构建一个新的测试函数来计算文档集的错误率
使用算法：构建一个完整的程序对一组文档进行分类，将错分的文档输出到屏幕上

6.1 准备数据：切分文本

使用string.split()方法对文本字符串进行切分

>>> mySent='This book is the best book on Python or M.L. I have ever laid eyes upon.'
>>> mySent.split()
['This', 'book', 'is', 'the', 'best', 'book', 'on', 'Python', 'or', 'M.L.', 'I', 'have', 'ever', 'laid', 'eyes', 'upon.']

可以看出将标点符号也当做了词的一部分。可以使用正则表达式来切分句子，分隔符是除单词、数字之外的任意字符串

mySent = 'This book is the best book on Python or M.L. I have ever laid eyes upon.'
    regEx = re.compile('\W+')
    listOfTokens = regEx.split(mySent)
    print(listOfTokens)

[‘This’, ‘book’, ‘is’, ‘the’, ‘best’, ‘book’, ‘on’, ‘Python’, ‘or’, ‘M’, ‘L’, ‘I’, ‘have’, ‘ever’, ‘laid’, ‘eyes’, ‘upon’, ‘’]

过滤掉其中空字符串的方法：

[tok for tok in listOfTokens if len(tok)>0]

由于这里的文本只看作词袋，希望所有词的形式是统一的，通过python内嵌的方法将字符串全部转换为小写（.lower()）或大写（.upper()）

[tok.lower() for tok in listOfTokens if len(tok)>0]

6.2 测试算法：使用朴素贝叶斯进行交叉验证

def textParse(bigString):  # 文件解析
    import re
    listOfTokens = re.split(r'\W+', bigString)
    return [tok.lower() for tok in listOfTokens if len(tok) > 2]  # 去掉少于2个字符的字符串，并将所有字符串转换为小写


def spamTest():  # 对贝叶斯垃圾邮件分类器进行自动化处理
    docList = [];
    classList = [];
    fullText = []
    for i in range(1, 26):  # 导入spam与ham下的文件，并将它们解析为词列表
        wordList = textParse(open('email/spam/%d.txt' % i).read())
        docList.append(wordList)
        fullText.append(wordList)
        classList.append(1)
        wordList = textParse(open('email/ham/%d.txt' % i).read())
        docList.append(wordList)
        fullText.append(wordList)
        classList.append(0)
    vocabList = createVocabList(docList)
    trainingSet = list(range(50))
    testSet = []
    for i in range(10):  # 随机选择10封电子邮件作为测试集
        randIndex = int(random.uniform(0, len(trainingSet)))  # random.uniform(a,b)返回a,b之间的随机浮点数
        testSet.append(trainingSet[randIndex])
        del (trainingSet[randIndex])
    trainMat = [];
    trainClasses = []
    for docIndex in trainingSet:  # 遍历训练集的所有文档，对每封邮件基于词汇表并使用setOfWords2Vec函数构建词向量
        trainMat.append(setOfWords2Vec(vocabList, docList[docIndex]))
        trainClasses.append(classList[docIndex])
    p0V, p1V, pSpam = trainNB0(array(trainMat), array(trainClasses))
    errorCount = 0
    for docIndex in testSet:  # 对测试集进行分类
        wordVector = setOfWords2Vec(vocabList, docList[docIndex])
        if classifyNB(array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:
            errorCount += 1
    print('the error rate is:', float(errorCount) / len(testSet))

7 示例：使用朴素贝叶斯分类器从个人广告中获取区域倾向

使用朴素贝叶斯来发现地域相关的用词
1.收集数据：从RSS源收集内容，需要对RSS源构建一个接口
2.准备数据：将文本文件解析成词条向量
3.分析数据：检查词条确保解析的正确性
4.训练算法：使用之前训练的trainNB0()函数
5.测试算法：观察错误率，确保分类器可用。可以修改切分程序，以降低错误率，提高分类结果
6.使用算法：构建一个完整的程序，封装所有内容。给定两个RSS源，该程序会显示最常用的公共词。