《机器学习实战》学习笔记（4、朴素贝叶斯）

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

可利用Python的文本处理能力，将文档切分成词向量，然后利用词向量对文档进行分类。

优点：数据少有效，可处理多类别。

缺点：只适合，标称型数据。

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

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

在文档分类中，整个文档是实例，而电子邮件中的某些元素则构成特征。

准备数据：可使用数值型或布尔型数据；分析数据：使用直方图；训练算法：计算特征的条件概率；测试算法：计算错误率；使用算法：可以在任意场景下使用。

若每个特征需要N个样本，那么1000个特征，就需要个样本。若特征之间相互独立，样本数则减少到1000xN；

编程假定：每个特征同等重要。

使用Python进行文本分类：

以在线社区留言板为例，构建步骤：

1、建立两个类别：侮辱类和非侮辱类，使用1和0分别表示，将文本转化为数字向量。2、然后基于这些向量，计算条件概率。

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

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)


# 将给定的inputSet代表的文章，转化成词向量
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

 

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

计算公式：

p(ci)：类别i中的文档数，除以总的文档数。

且w可展开为一个个独立特征，那么就可以将上述概率写作：=

某一类别条件下，各个特征的概率计算：

# trainCategory类别标签所构成的向量
def trainNB0(trainMatrix, trainCategory):
    numTrainDocs = len(trainMatrix)  # 文档矩阵行数
    numWords = len(trainMatrix[0])  # 一篇文档包含的词数
    # 任意文档属于侮辱性文档的概率
    pAbusive = sum(trainCategory) / float(numTrainDocs)
    p0Num = ones(numWords) #防止某个条件概率为0
    p1Num = 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 = log(p1Num / p1Denom)  # 在侮辱性类别的条件下，各个特征的概率 p(wi|c1)
    p0Vect = log(p0Num / p0Denom)  # 在正常类别的条件下，各个特征的概率 p(wi|c0)
    return p0Vect, p1Vect, pAbusive

 

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

在对文档进行分类时，计算多个概率的乘积，以获得文档属于某个类别的概率：

太多很小的数相乘，会造成程序下溢出。可对乘积取自然对数。

ln(a*b) = ln(a) + ln(b) # 且f(x)和ln(f(x))，在相同区域内，有相同的单调性，且在同一点处取到极值。

使用分类器：

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))

ps：sum(vec2Classify * p1Vec)为某一特征出现的概率，乘以在侮辱类别的条件特征出现的概率。

但为啥后面还要加上log(pClass1)？

 

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

词集模型：将每个词的出现与否作为一个特征。

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

词袋模型代码：

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

 

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

(1)提供文本文件；(2)将文本本间解析成词条向量，检查词条确保解析正确性；(3)使用trainNB0()函数；

(4)使用classifyNB()，计算文档集的错误率；(5)对一组文档进行分类。

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

def textParse(bigString):
    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)  # 获取单词集合
    trainingSet = range(50)  # 构建训练集标号(0-49)
    testSet = []  # 构建测试集标号
    # 随机选择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(bagOfWords2VecMN(vocabList, docList[docIndex]))
        trainClasses.append(classList[docIndex])
    p0V, p1V, pSpam = trainNB0(array(trainMat), array(trainClasses))
    errorCount = 0
    for docIndex in testSet:
        # 将训练集转化为词向量
        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))

ps：将垃圾邮件误判为正常邮件，要比将正常邮件归到垃圾邮件好。

 

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

收集数据：从RSS源收集内容，对RSS源构建一个接口。可修改切分程序，以降低错误率，提高分类结果。