朴素贝叶斯-Machine Learining In Action学习笔记

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

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

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

条件概率：p(x,y|c?) 需要先验知识和逻辑推理

频数概率：从数据本身获得结论，并不考虑逻辑推理及先验知识

朴素贝叶斯的一般过程：

1. 收集数据：可以使用任何方法。

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

3. 分析数据：有大量特征时，绘制特征作用不大，此时使用直方图效果更好。

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

5. 测试算法：计算错误率。

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

如果每个特征需要N个样本，那么对于10个特征将需要N^10个样本。

如果特征之间相互独立，那么样本数就可以从N^1000减少到1000×N。

朴素贝叶斯分类器中朴素（naive）一词：假设每个特征同等重要。

朴素贝叶斯分类器通常有两种实现方式：一种基于贝努利模型实现，一种基于多项式模型实现。这里采用前一种实现方式。该实现方式中并不考虑词在文档中出现的次数，只考虑出不出现，因此在这个意义上相当于假设词是等权重的（独立）。

粗体w表示这是一个向量，即它由多个数值组成。

伪代码：

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

对每篇训练文档：

对每个类别：

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

增加所有词条的计数值

对每个类别：

对每个词条：

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

返回每个类别的条件概率

注意：

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

    p0Num, p1Num = zeros(numWords), zeros(numWords)
    p0Denom, p1Denom = 0.0, 0.0

更改为：

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

2.另一个遇到的问题是下溢出，这是由于太多很小的数相乘造成的。当计算乘积p(w0|ci)p(w1|ci)p(w2|ci)...p(wN|ci)时，由于大部分因子都非常小，所以程序会下溢出或者得到不正确的答案。（用Python尝试相乘许多很小的数，最后四舍五入后会得到0。）

一种解决办法是对乘积取自然对数。通过求对数可以避免下溢出或者浮点数舍入导致的错误。同时，采用自然对数进行处理不会有任何损失 。

    p1Vect = p1Num / p1Denom
    p0Vect = p0Num / p0Denom

改为：

    p1Vect = log(p1Num / p1Denom)
    p0Vect = log(p0Num / p0Denom)

词集模型：每个词的出现与否作为一个特征（每个词只能出现一次）

词袋模型：每个单词可以出现多次。

setOfWords2Vec函数仅考虑词集模型，bagOfWords2VecMN函数则是基于文档词袋模型改进后的函数。

示例1：使用朴素贝叶斯对电子邮件进行分类

收集数据：提供文本文件。

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

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

训练算法：使用我们之前建立的trainNB0()函数。

测试算法：使用classifyNB()，并且构建一个新的测试函数来计算文档集的错误率。

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

留存交叉验证：随机选择数据的一部分作为训练集，而剩余部分作为测试集。

所有代码：

# -*- coding:utf-8 -*-
from numpy import *


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([])
    for document in dataSet:
        vocabSet = vocabSet | set(document)
    return list(vocabSet)


# 输入词汇列表和某个文档，输出文档向量，向量的每一元素为1或0，分别表示词汇表中的单词在输入文档中是否出现。
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


# 基于文档词袋模型改进后的模型
def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0] * len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
    return returnVec


# 输入参数为文档矩阵trainMatrix，以及由每篇文档类别标签所构成的向量trainCategory
def trainNB0(trainMatrix, trainCategory):
    numTrainDocs = len(trainMatrix)
    numWords = len(trainMatrix[0])
    pAbusive = sum(trainCategory) / float(numTrainDocs)  # 2分类问题，仅0,1构成向量，此处计算1
    p0Num, p1Num = ones(numWords), ones(numWords)
    p0Denom, p1Denom = 2.0, 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)
    p0Vect = log(p0Num / p0Denom)

    return p0Vect, p1Vect, pAbusive


# 要分类的向量vec2Classify
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    p1 = sum(vec2Classify * p1Vec) + log(pClass1)
    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)


# 文件解析及完整的垃圾邮件测试函数
def textParse(bigString):
    import re
    listOfTokens = re.split(r‘\W*‘, bigString)
    return [tok.lower() for tok in listOfTokens if len(tok) > 2]


def spamTest():
    import random
    # 导入并解析文本文件
    docList, classList, fullText = [], [], []
    for i in range(1, 26):
        wordList = textParse(open(‘email/spam/%d.txt‘ % i, ‘r‘).read())
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1)

        wordList = textParse(open(‘email/ham/%d.txt‘ % i, ‘r‘).read())
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)

    vocabList = createVocabList(docList)
    trainingSet = range(50)
    testSet = []
    # 随机构建训练集(训练集40个，测试集10个)
    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:
        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)

来自为知笔记(Wiz)