机器学习004_朴素贝叶斯

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

优点：在数据较少的情况下仍然有效，可以处理多类别问题

缺点：对于输入数据的准备方式较为敏感

适用数据类型：标称型数据

“朴素”——整个形式化过程只做最原始、最简单的假设。

朴素贝叶斯是贝叶斯决策论的一部分，选择具有最高概率的决策。

Thomas Bayes 通过引入先验知识和逻辑推理来处理不确定命题。

概率、条件概率、贝叶斯准则

P（x，y | c）表示在环境条件c下，点（x，y）属于其类的概率是多少

贝叶斯准则：P（c | x）= P（x | c）P（c）/ P（x）即交换条件概率中的条件与结果

P（c | x，y）表示给定某个由x，y表示的数据点，那么该数据点来自类别c的概率是多少？

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

通过观察文档中出现的词，并把每个词的出现或者不出现作为一个特征，这样得到的特征数目就会跟词汇表中的词目一样多。

朴素贝叶斯的一般过程：

（1）收集数据：使用RSS源

（2）准备数据：需要数值型或者布尔型数据

（3）分析数据：有大量特征时，绘制特征作用不大，这里使用直方图

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

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

（6）使用算法：一个常见的朴素贝叶斯应用是文档分类，可以在任意的分类场景中使用朴素贝叶斯分类，不一定非要是文本。

朴素贝叶斯分类器通常有两种实现方式：一种是基于贝努利模型实现，一种基于多项式模型实现，我们采用前一种，即假设每个特征同样重要，不考虑词在文档中出现的次数，只考虑出不出现，也可以认为假设词是等权重的。

比如要用来判断留言板的留言是否得当，可能不需要看完所有的1000个单词，而只需要看10~20个特征就足以做出判断。

1.3 使用Python进行文本分类

特征定义：来自文本的词条（token）一个词条是字符的任意组合

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

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 is abusive, 0 not
    return postingList,classVec

def createVocabList(dataSet):
    vocabSet = set([])  #create empty set
    for document in dataSet:
        vocabSet = vocabSet | set(document) #union of the two sets
    return list(vocabSet)

def setOfWords2Vec(vocabList, inputSet):
    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

第三个函数setOfWords2Vec（vocabList，inputSet）输入参数为词汇表及某个文档，输出是文档向量，向量的每一元素为1或0，分别表示词汇表中的单词在输入文档中是否出现。

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

准备数据中介绍了如何将一组单词转换为一组数据，然后我们要使用这些数字计算概率，现在已经知道一个词是否出现在一篇文档中，也知道该文档所属的类别。

伪代码：

计算每个类别中的文档数目

对每篇训练文档：

        对每个类别：

                 如果词条出现在文档中——增加该词条的计数值

                 增加所有词条的计数值

对每个类别：

         对每个词条：

                  将该词条的数目除以总词条数目得到条件概率

返回每个类别的条件概率

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

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

一旦某个词语（侮辱性或者正常词语）在某一文档中出现，则该词对应的个数（p1Num或者p0Num）就加1，而且在所有的文档中，该文档的总词数也相应加1，对于两个类别都要进行同样的处理。

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

存在的问题及解决方案：

（1）利用贝叶斯分类器对文档进行分类时，要计算许多个概率的乘积以获得文档属于某个类别的概率，如果其中一个概率值为0，那么最后的乘积也会为0，所以我们在初始化的时候，将所有词的出现数初始化为1，并将分母初始化为2。

（2）下溢出，太多很小的数相乘，程序会下溢出，或者得不到正确的答案。通过求对数可以避免下溢出或者浮点数舍入导致的错误，同时，采用自然对数进行处理不会有任何损失。

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)

准备数据：文档词袋模型

我们将每个词的出现与否作为一个特征，可以描述为词集模型。

如果一个词在文档中出现不止一次，这可能意味着包含该词是否出现在文档中所不能表达的某种信息，这种方法被称为词袋模型。

在词袋中，每个单词可以出现多次；在词集中，每个词只能出现一次。

朴素贝叶斯词袋模型：每当遇到一个单词时，它会增加词向量中的对应值，而不只是将对应的数值设为1。

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

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

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

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

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

（4）训练算法：使用我们之前建立的trainNB0（）函数

（5）测试算法：使用classifyNB（）并且构建一个新的测试函数来计算文档集的错误率

（6）使用算法：构建一个完整的程序对一组文档进行分类，将错分的文档输出到屏幕上

准备数据：切分文本

从文档中构建自己的词列表。

使用正则表达式来切分句子，其中分隔符是除单词、数字外的任意字符串。

将空字符去掉，只返回长度大于0的字符串。

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

文件解析及完整的垃圾邮件测试函数

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

注意：

问题：UnicodeDecodeError: 'gbk' codec can't decode byte 0xae in position 199: illegal multibyte sequence

解决办法：打开email\ham\23.txt，找到SciFinance?，把?替换成空格即可。

问题：TypeError: 'range' object doesn't support item deletion

解决办法：trainingSet = range(50) 改为 trainingSet = list(range(50))

第一个函数textParse（）接受一个大字符串并将其解析为字符串列表。

第二个函数spamTest（）对贝叶斯垃圾邮件分类器进行自动化处理。

导入文件夹spam和ham，这里对应的文件是进行打标签的，通过ClassList.append(1/0)，将这些数据解析为词列表。

然后构建测试集与训练集。选出的数字所对应的文档添加到测试集，同时也将其从训练集中剔除。

即为k-折交叉验证（留存交叉验证）

接下来的for循环遍历训练集所有文档，对每封邮件基于词汇表并使用setOfWords2Vec（）函数来构建词向量。这些词在traindNB0（）函数中用于计算分类所需的概率。

然后遍历测试集，对其中每封邮件进行分类。