概述

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

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

假设现在有一个数据集，由两类数据组成，数据分布如下图所示。

示例数据

用p1(x,y)表示数据点(x,y)属于类别1的概率，用p2(x,y)表示数据点(x,y)属于类别2的概率。那么，对于一个新数据点，可以用下面的规则来判断类别：

• ，则为类别1
• ，则为类别2

这就是贝叶斯决策理论的核心思想，即选择具有最高概率的决策。

条件概率

假设现在有3块灰色石头和4块黑色石头，一共7块。那么随机取一块石头是灰色的概率是3/7，黑色的概率是4/7。我们用表示取到灰色的概率，则。

石头

如果把石头放进两个箱子里。上述概率该怎么算？

两箱石头

假设计算的是从B取到灰色石头的概率，这个概率可以记作，可称之为“在已知石头出自B的情况下，取出灰色石头的概率”，这就是所谓的条件概率。
不难得到，。
条件概率的计算公式如下：

：灰色且在B的石头的概率，值为1/7。
：在B的石头概率，值为3/7。
相除即可得到。

另一种有效计算条件概率的方法是贝叶斯准则，告诉我们如何交换条件概率中的条件和结果，即如果已知，要求，则可用下面公式：

文本分类

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

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(vocabList, inputSet):
    returnVec = [0] * len(vocabList)   # 创建一个元素都为0的向量
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] = 1
    return returnVec

第一个函数loadDataSet()创建一些实验样本，第一个返回值为文档集合，第二个是类别标签的集合。

第二个函数createVocabList()返回一个包含在所有文档中出现的不重复的列表。

获得词汇表后，便可以使用函数setOfWords2Vec()，输入参数为词汇表和某个文档，输出文档向量。

从词向量计算概率

假设词向量为w，类别为c，则某个词向量属于类别的概率如下式子所示：

import numpy as np

# 朴素贝叶斯分类器训练函数
def trainNB0(trainMatrix, trainCategory):
    numTrainDocs = len(trainMatrix) 
    numWords = len(trainMatrix[0])   
    pAbusive = sum(trainCategory)/float(numTrainDocs) # 侮辱性文档的概率
    # 初始化概率
    p0Num = np.ones(numWords)
    p1Num = np.ones(numWords)
    p0Denom = 2.0
    p1Denom = 2.0
    
    for i in range(numTrainDocs):
        if trainCategory[i] == 1:
            p1Num += trainMatrix[i]   # 向量相加
            p1Denom += sum(trainMatrix[I])
        else:
            p0Num += trainMatrix[i]   # 向量相加
            p0Denom += sum(trainMatrix[I])
    p1Vect = np.log(p1Num/p1Denom)
    p0Vect = np.log(p0Num/p0Denom)
    return p0Vect, p1Vect, pAbusive

1. pNum初始化为1，pDenom初始化为2的原因
   利用贝叶斯分类器对文档分类时，要计算多个概率的乘积以获得文档属于某个类别的概率，即计算。如果某个概率值为0，那么最后乘积也为0。为降低这种影响，将所有词出现的次数初始化为1，分母初始化为2
2. 概率取对数的原因
   解决下溢出问题。在代数中有，于是通过求对数可以避免下溢出或者浮点数舍入导致的错误。而且取对数对最终结果没有影响。可以见下图的对比。
   
   对比

测试算法

# 朴素贝叶斯分类器
def classifyNB(vec2Classify, p0Vec, p1Vec, 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 testingNB():
    listOPosts,listClasses = loadDataSet()
    myVocabList = createVocabList(listOPosts)
    trainMat=[]
    for postinDoc in listOPosts:
        trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
    p0V,p1V,pAb = trainNB0(np.array(trainMat),np.array(listClasses))
    testEntry = ['love', 'my', 'dalmation']
    thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))
    print(testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb))
    testEntry = ['stupid', 'garbage']
    thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))
    print(testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb))

执行测试函数testingNB()得到以下结果。

['love', 'my', 'dalmation'] classified as:  0
['stupid', 'garbage'] classified as:  1

示例：过滤垃圾邮件

# 文本解析
def textParse(bigString):
    import re
    listOfTokens = re.split(r'\W*', bigString)
    return [tok.lower() for tok in listOfTokens if len(tok) > 2]

def spamText():
    docList = []
    classList = []
    fullText = []
    # 导入并解析文本文件
    for i in range(1, 26):
        try:
            # 垃圾邮件
            wordList = textParse(open('email/spam/%d.txt' % i).read())
        except UnicodeDecodeError:
            print('spam:', i)
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1)
        try:
            # 正常邮件
            wordList = textParse(open('email/ham/%d.txt' % i).read())
        except UnicodeDecodeError:
            print('ham:', i)
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)
        
    vocabList = createVocabList(docList)
    # 随机构建训练集和测试集，留存交叉验证
    trainingSet = list(range(50))
    testSet = []
    for i in range(10):
        randIndex = int(np.random.uniform(0, len(trainingSet)))
        testSet.append(trainingSet[randIndex])
        del(trainingSet[randIndex])
    trainMat = []
    trainClass = []
    for docIndex in trainingSet:
        trainMat.append(setOfWords2Vec(vocabList, docList[docIndex]))
        trainClass.append(classList[docIndex])
    p0V, p1V, pSpam = trainNB0(np.array(trainMat), np.array(trainClass))
    errorCount = 0
    for docIndex in testSet:
        wordVector = setOfWords2Vec(vocabList, docList[docIndex])
        if classifyNB(np.array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:
            errorCount += 1
    errorRate = float(errorCount)/len(testSet)
    print('the error rate is:', errorRate)
    return errorRate

spamText()对邮件进行自动分类，这里只做了一次迭代。为了更精确估计错误率，可以进行多次迭代算出平均错误率。

sumOfErrorRate = 0.0
for i in range(10):
    sumOfErrorRate += spamText()
print('average of error rate is:', sumOfErrorRate / 10)

结果如下：

the error rate is: 0.1
the error rate is: 0.1
the error rate is: 0.1
the error rate is: 0.1
the error rate is: 0.0
the error rate is: 0.0
the error rate is: 0.0
the error rate is: 0.0
the error rate is: 0.0
the error rate is: 0.0
average of error rate is: 0.04

小结

贝叶斯准则提供了一种利用已知值来估计未知概率的方法

独立性假设是指一个词的出现概率并不依赖于文档中的其他词。朴素贝叶斯朴素两个字的由来。