机器学习：朴素贝叶斯

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

1.1 朴素贝叶斯

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

之所以称为朴素，是因为整个形式化过程只做最原始、最简单的假设。

1.2 贝叶斯决策理论

假设有一个数据集由两类数据组成，数据分布如图：
(两个参数已知的概率分布，参数决定了分布的形状)

假设有位读者找到了描述了图中两类数据的统计参数。现在用p1(x,y)表示数据点(x,y)属于类别1的概率(圆点)，用p2(x,y)表示数据点(x,y)属于类别2的概率(三角形)。那么对于一个新数据点(x,y)，可以用下面的规则来判断它的类别：

如果p1(x,y) > p2(x,y)，那么类别为1。
如果p1(x,y) < p2(x,y)，那么类别为2。

贝叶斯决策的核心思想是选择具有最高概率的决策。回到上图，如果该图的整个数据使用6个浮点数来表示，并且计算类别概率的python代码只有两行。有以下方法：

1.使用knn算法，进行1000次距离计算
2.使用决策树，分别沿x轴，y轴划分数据
3.计算数据点属于每个类别的概率，并进行比较

使用决策树不会非常成功；而knn算法计算量太大。

二、条件概率

假设现在有一个装了七块石头的罐子，3块灰色，4块黑色（如图）。从罐子中随机取出一块石头，那么灰色的概率是3/7，黑色概率是4/7。使用P(gray)表示取到灰色石头的概率。

如果七块石头如图放在两个桶中：

假定计算的是从B桶取到灰色的概率，记作P(gray|bucketB)，称为“在已知石头出自B桶的情况下，取出灰色石头的概率”，易得，P(gray|bucketA) = 2/3，P(gray|bucketB) = 1/3。

条件概率的计算公式如下：

另一种有效计算条件概率的方法称为贝叶斯准则。即如果已知P(x|c)，要求P(c|x)，那么可以使用下面的计算方法：

三、使用条件概率来分类

我们需要计算和比较p(c1|x,y)和p(c2|x,y)，这代表的具体意义是：给定某个由x、y表示的数据点，那么该数据点分别来自c1、c2的概率是多少？
应用贝叶斯准则得到：

使用这些定义，可以定义贝叶斯分类准则为：

如果p(c1|x,y) > p(c2|x,y)，那么属于类别c1。
如果p(c1|x,y) < p(c2|x,y)，那么属于类别c2。

使用贝叶斯准则，可以通过已知的三个概率值来计算未知的概率值。

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

在文档分类中，整个文档(如一封电子件)是实例，而电子邮件中的某些元素则构成特征。虽然电子邮件是一种会不断增加的文本，但我们同样可以对新闻报道、用户留言、政府公文等其他任意类型的文本进行分类。我们可以观察文本中不断出现的词，并把每个词的出现或者不出现作为一个特征，这样得到的特征数目就会跟词汇表中的词目一样多。朴素贝叶斯是上节介绍的贝叶斯分类器的一个扩展，是用以文档分类的算法。

朴素贝叶斯的一般过程

• 收集数据：可以使用任何方法。
• 准备数据：数值型或布尔型数据。
• 分析数据：有大量特征时，绘制特征作用不大，直方图效果更好。
• 训练算法：计算不同的独立特征的条件概率。
• 测试算法：计算错误率。
• 使用算法：一个常见的朴素贝叶斯应用是文档分类。可以在任意的分类场景中使用朴素贝叶斯分类器，不一定非要是文本。

假设词汇表中有1000个单词。要得到好的概率分布，就需要足够的数据样本，假定样本数为N。由统计学知，如果每个特征需要N个样本，那么对于包含1000个特征的词汇表将需要N¹⁰⁰⁰个样本。即所需要的样本数会随着特征数目增大而迅速增长。
如果特征之间相互独立，那么样本数就可以从N¹⁰⁰⁰减少到1000*N。所谓独立，指的是统计意义上的独立，即一个特征或者单词出现的可能性与它和其它单词相邻没有关系。举例说明，假设单词bacon出现在unhealthy后面与出现在delicious后面的概率相同。当然，我们知道这种假设并不准确，但这个假设就是朴素贝叶斯中朴素的含义。朴素贝叶斯分类器中的另一个假设是，每个特征同等重要。但这个假设也有问题。如果要判断留言板的留言是否得当，那么可能不需要看完所有的1000个单词，而只需要10~20个特征就可以做出判断了。尽管如此，朴素贝叶斯的实际效果已经很好了。

五、使用Python进行分类

要从文本中获取特征，需要先拆分文本。这里的特征是来自文本的词条(token)，一个词条是字符的任意组合。可以把词条想象为单词，也可以使用非单词词条，如URL、IP地址或者任意其他字符串。然后将每一个文本片段表示为一个词条向量，其中值为1表示词条出现在文档中，0表示未出现。
以在线社区的留言为例。我们要屏蔽侮辱性的言论，所以要构建一个快速过滤器，如果某条言论使用侮辱性语言，那么标识其为内容不当，过滤该类内容。对此建立两个类别：侮辱类和非侮辱类，分别用1和0表示。
接下来将首先给出将文本转换为数字向量的过程，然后介绍如何基于这些向量来计算条件概率，并在此基础上构建分类器。

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) #union of the two sets
    return list(vocabSet)

def setOfWords2Vec(vocabList, inputSet):
	# 创建一个其中所含元素都为0的向量
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] = 1
        else: print "the word: %s is not in my Vocabulary!" % word
    return returnVec

函数loadDataSet()创建了一些实验样本。该函数返回的第一个变量是进行词条切分后的文档集合。这些留言文本被切分成一系列的词条集合，标点符号从文本中去掉。该函数返回的第二个变量是一个类别标签的集合。这里分为侮辱类和非侮辱类，这些文本的类别由人工标注，这些标注信息用于训练程序以便自动监测侮辱性留言。

函数createVocabList()会创建一个包含在所有文档中出现的不重复词的列表，为此使用Python的set数据类型。将词条列表输给set构造函数，set会返回一个不重复词表。首先，创建一个空集合，然后将每篇文档返回的新词集合添加到该集合中。操作符|用于求两个集合的并集，这也是一个按位或(OR)操作符。

获得词汇表后，函数setOfWords2Vec()的输入参数为词汇表及某个文档，输出的是文档向量，向量的每一元素为1或0，分别表示词汇表中的单词在输入文档中是否出现。函数首先创建一个和词汇表等长的向量，并将其元素都设置为0.接着，遍历文档中所有的单词，如果出现词汇表中的单词，则将输出的文档向量中的对应值设为1。

查看效果：

可以发现，上述词表不会出现重复的单词。setOfWords2Vec()函数使用词汇表或者想要检查的所有单词作为输入，然后为其中每一个单词构建一个特征。

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

前面介绍了如何将一组单词转换为一组数字，接下来看看如何用这个数字计算概率。我们已经知道一个词是否出现在一篇文档中，也知道该文档的类别。重写贝叶斯，将x、y替换为w，粗体w表示这是一个向量，即它由多少个数值组成。在这个例子中，数值个数与词汇表中的词个数相同。

使用上述公式，对每个类计算该值，然后比较这两个概率值的大小，首先通过类别i(侮辱或非侮辱留言)中文档数除以总文档数来计算概率p(ci)。接下来计算p(w|ci)，这里就要用到朴素贝叶斯假设。如果将w展开为一个个独立特征，那么就可以将上述概率写作p(w0,w1,w2,w3…wn|ci)。这里假设所有词都相互独立，该假设也称作条件独立性假设，它意味着可以使用**p(w0|ci)p(w1|ci)p(w2|ci)…p(wn|ci)**来计算上述概率，这就极大地简化了计算过程。

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

朴素贝叶斯分类器训练函数：

def trainNB0(trainMatrix,trainCategory):
    numTrainDocs = len(trainMatrix)
    numWords = len(trainMatrix[0])
    # 初始化概率
    pAbusive = sum(trainCategory)/float(numTrainDocs)
    p0Num = ones(numWords); p1Num = ones(numWords)      #change to ones() 
    p0Denom = 2.0; p1Denom = 2.0                        #change to 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 = log(p1Num/p1Denom)          #change to log()
    p0Vect = log(p0Num/p0Denom)          #change to log()
    return p0Vect,p1Vect,pAbusive

函数中的输入参数为文档矩阵trainMatrix，以及由每篇文档类别标签所构成的向量trainCategory。首先计算文档属于侮辱性的概率(class=1)，即p(1)。因为这是一个二类分类问题，所以通过1-p(1)得到p(0)。

计算p(wi|c1)和p(wi|c0)，需要初始化程序中的分子变量和分母变量。程序中的分母变量是一个元素个数等于词汇表大小的Numpy数组。在for循环中，要遍历训练集trainMatrix中的所有文档。一旦某个词在某一文档中出现，则该词对应的个数(p1Num或p0Num)就加1，而且在所有文档中，该文档的总词数也相应加1。对于两个类别都要进行同样的计算处理。

最后。对每个元素除以该类别中的总词数。利用Numpy可以很好地实现，用一个数组除以浮点数即可，若使用常规的python列表则难以完成这种任务。最后，函数会返回两个向量和一个概率。

pAb就是任意文档属于侮辱性文档的概率，为0.5。

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

利用贝叶斯分类器对文档进行分类时，要计算多个概率的乘积以获得文档属于某个类别的概率，即计算p(w0|1) p(w1|1) p(w2|1)。如果其中一个概率为0，那么结果也为0。为降低这种影响，可以将所有词的出现数初始化为1，并将分母初始化为2。

p0Num = ones(numWords); p1Num = ones(numWords) 
p0Denom = 2.0; p1Denom = 2.0 

另一个问题是下溢出，这是由于太多很小的数造成的，当计算乘积**p(w0|ci)p(w1|ci)p(w2|ci)…p(wn|ci)**时，由于大部分因子都非常小，所以会造成下溢出。一种解决办法是对乘积取自然对数。在代数中有ln(a*b) = ln(a)+ln(b)，于是通过求对数可以避免下溢出或者浮点数舍入导致的错误。如图给出函数f(x)与ln(f(x))的曲线。检查这两条曲线发现它们在相同的区域内同时增加或者减少，并且在相同点上取到极值。虽然取值不同，但不影响最终结果。

代码为：

p1Vect = log(p1Num/p1Denom)          #change to log()
p0Vect = log(p0Num/p0Denom)          #change to log()

朴素贝叶斯分类函数：

def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    p1 = sum(vec2Classify * p1Vec) + log(pClass1)    #element-wise mult
    p0 = sum(vec2Classify * p0Vec) + 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(array(trainMat),array(listClasses))
    testEntry = ['love', 'my', 'dalmation']
    thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
    print(testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb))
    testEntry = ['stupid', 'garbage']
    thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
    print(testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb))

这里有四个输入：要分类的向量vec2Classify以及函数trainNB0()计算得到的三个概率。使用Numpy的数组来计算两个向量相乘的结果。这里的相乘指的是对应元素相乘，即先将两个向量中的第一个元素相乘，然后将第二个元素相乘，以此类推。接下来将词汇表中所有词的对应值相加，然后将该值加到类别的对数概率上。最后比较类别的概率返回大概率对应的类别标签。

代码的第二个函数是一个便利函数，该函数封装所有操作，以节省输入代码的时间。
查看效果：

5.4 准备数据：文档词袋模型

我们将每个词的出现与否作为一个特征，这可以被描述为词集模型。如果一个词在文档中出现不止一次，这可能意味着包含改词是否出现在文档中所不能表达的某种信息，这种方法称为词袋模型。在词袋中，每个单词可以出现多次，而在词集中，每个词只能出现一次。为适应词袋模型，需要对函数setOfWords2Vec()修改为bagOfWords2Vec()。该函数不同的是每当遇到一个单词时，它会增加词向量中的对应值，而不只是将对应的数值设为1。

朴素贝叶斯词袋模型：

def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
    return returnVec

六、电子邮件垃圾过滤

步骤：

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

6.1 准备数据：切分文本

对于一个文本字符串，可以使用Python的string.split()方法将其切分。

if __name__ == '__main__':
    mysent = 'This book is the best book on Python or M.L. I have ever laid eyes upon.'
    print(mysent.split());

可以看到，切分结果不错，但是标点符号也被当成了字符串的一部分。可以使用正则表示式来切分句子，其中分隔符是除单词、数字外的任意字符串。

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

现在得到了一系列词组成的词表，但是里面的空字符串需要去掉。可以计算每个字符串的长度，只返回长度大于0的字符串。

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

我们知道句子中的第一个单词是大写。如果目的是句子查找，会很有用。但这里的文本只看成词袋，所以我们希望所有词的形式都是统一的，不论它们出现在句子中间、结尾还是开头。

.lower()将字符串转换成小写，.upper将字符串转换成大写。

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

现在来看数据集中一封完整的的电子邮件的实际处理效果。

regEx = re.compile('\\W*')
print(regEx)
emailText = open('ham/6.txt').read()
listOfTokens = regEx.split(emailText)
# listOfTokens = regEx.split(mySent)
listOfTokens = [tok for tok in listOfTokens if len(tok) > 0]
print(listOfTokens)

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

下面将文本解析器集成到一个完整分类器中。
文件解析及完整的垃圾邮件测试函数：

def textParse(bigString):    #input is big string, #output is word list
    import re
    listOfTokens = re.split(r'\W+', bigString)
    return [tok.lower() for tok in listOfTokens if len(tok) > 2] 
    
def spamTest():
    docList=[]; classList = []; fullText =[]
    for i in range(1,26):
    	# 导入并解析文本文件
        wordList = textParse(open('email/spam/%d.txt' % i).read())
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1)
        wordList = textParse(open('email/ham/%d.txt' % i).read())
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)
    vocabList = createVocabList(docList)#create vocabulary
    trainingSet = range(50); testSet=[]           #create test set
    # 随机构建训练集
    for i in range(10):
        randIndex = int(random.uniform(0,len(trainingSet)))
        testSet.append(trainingSet[randIndex])
        del(trainingSet[randIndex])  
    trainMat=[]; trainClasses = []
    # 对测试集进行分类
    for docIndex in trainingSet:#train the classifier (get probs) trainNB0
        trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
        trainClasses.append(classList[docIndex])
    p0V,p1V,pSpam = trainNB0(array(trainMat),array(trainClasses))
    errorCount = 0
    for docIndex in testSet:        #classify the remaining items
        wordVector = bagOfWords2VecMN(vocabList, docList[docIndex])
        if classifyNB(array(wordVector),p0V,p1V,pSpam) != classList[docIndex]:
            errorCount += 1
            print("classification error",docList[docIndex])
    print('the error rate is: ',float(errorCount)/len(testSet))
    #return vocabList,fullText

函数textParse()接受一个大字符串并将其解析为字符串列表。该函数去掉少于两个字符的字符串，并将所有字符串转换为小写。

函数spamTest()对贝叶斯垃圾邮件分类器进行自动化处理。导入文件夹spam和ham下的文本文件，将它们解析为词列表。接下来构建一个测试集与一个训练集，两个集合中的邮件都是随机选出的。分类器所需要的概率计算只利用训练集中的文档来完成。Python变量trainingSet是一个整数列表，其中的值从0到49。接下来随机选择其中10个文件。选择出的数字所对应的文档被添加到测试集，同时也将其从训练集中剔除。这种随机选择数据的一部分作为训练集，剩余部分作为测试集的过程称为留存交叉验证。进行多次迭代后求出平均错误率，使得结果更加精确。

for循环遍历训练集的所有文档，对每封邮件基于词汇表并使用setOfWords2Vec()函数来构建词向量。这些词在traindNB0()函数中用于计算分类所需的概率。然后遍历测试集，对其中每封电子邮件进行分类。如果邮件分类错误，则错误数加1，最后给出总的错误百分比。

函数spamTest()会输出在10封随机选择的电子邮件上的分类错误率。如果发现错误的话，函数会输出错分文档的词表，这样就可以了解那篇文档发生了错误。通过重复多次然后求平均值的方式可以更好地估计错误率。