《机器学习实战》chapter04 使用Python进行文本分类

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

使用朴素贝叶斯计算每一封邮件是垃圾邮件的概率p1和非垃圾邮件的概率p0，如果p1 > p0，则是垃圾邮件，否则不是。

首先，我们先介绍一个例子：

对于任意一条评论是否带有侮辱性质？我们通常看这个评论中是否包含侮辱性词汇，对于人来说，侮辱性词汇我们一眼就能够看出来，可是计算机并不理解什么是侮辱性，而我们又不能直接告诉计算机哪些词是侮辱性的，因为我们也列举不全，我们应该让程序本身去判断一个词是侮辱性的概率，所以我们需要通过给定数据集训练算法。

表示句子中包含w（单词组合）时是侮辱性或非侮辱性的概率

所以：表示这个句子是侮辱性（非侮辱性）的概率，等于训练集中侮辱性的句子总数/总句子数（非侮辱性的句子总数/总句子数）

表示这个句子是侮辱性（非侮辱性）条件下句子里每一个单词是侮辱性（非侮辱性）的概率

表示这个句子中每一个单词在总的训练集下出现的概率

当需要测试一个句子是否有侮辱性时，我们只需要判断这个句子是侮辱性的概率是否大于非侮辱性的概率 (p1>p0?)

转化成代码上的一些实现问题：

表达式，其中w是一个向量，表示在条件下这个句子中每一个单词出现的概率，为了使这个公式的可编程性更好我们把他转换成两个向量的乘积：

Vec2Classify*p1Vec

这两个向量的长度都是训练集中所有词汇的集合（无重复）长度

Vec2Classify中把在当前句子中出现了的单词索引位置置为1，未出现的置为0。

p1Vec训练集中所有出现过的单词是侮辱性的概率（侮辱性的概率用每个单词在侮辱性句子中出现的频数/侮辱性句子中总的单词数表示，非侮辱性保存在p0Vec中）

用每个单词在训练集所有句子中出现的频数/所有句子总的单词数。又因为我们最终要判断的是p1>p0?而在p1和p0的计算中都会除以这个值，且这个值是一样的，所以我们可以不用计算，直接省去。

过滤邮件与这个其实就是一样的。

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

• 从文本中构建词向量
• 参数：a、词汇表；b、输入的文档
• 对于文档进行切分：a、以字母数字之外的字符作为分隔符切分；b、去掉切分后生成的空白串；c、统一词格式（都变小写）；

# 字符串拆分、小写、去除长度小于3的
def textParse(bigString):
    listOfTokens = re.split('\w+', bigString)
    return [tok.lower() for tok in listOfTokens if len(tok) > 2]

textParse()函数接受一个大字符串并将其解析为字符串列表

# 创建实验样本
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']]
    # 0代标非侮辱性言论， 1代标侮辱性言论
    classVec = [0, 1, 0, 1, 0, 1]
    return postingList, classVec


# 创建一个包含在所有文档中出现的不重复的词表
def createVocabList(dataSet):
    # 创建一个空集
    vocabSet = set([])
    # 将每篇文档返回的新词集合添加到该集合中
    for document in dataSet:
        # 创建两个集合的并集
        vocabSet = vocabSet | set(document)
    return list(vocabSet)


# vocabList 词汇表, inputList 文档， 返回值 文档向量
def setOfWords2Vec(vocabList, inputSet):
    # 创建一个其中所含元素都为0的向量，表示词汇表中的单词是否在文档中出现
    returnVec = [0] * len(vocabList)
    # 遍历文档中的所有单词，检查是否出现在词汇表中
    for word in inputSet:
        if word in vocabList:
            # 在词汇表中出现，标记为1
            returnVec[vocabList.index(word)] = 1
        else:
            print("the word: %s is not in my vocabulary!" % word)
    # 返回文档向量，
    return returnVec

loadDataSet()函数是在之前没用文本里的数据时建的一个测试数据集，加载了一个实验样本

createVocabList()会创建一个包含在所有文档中出现的不重复词列表

获得词汇表后，使用setOfWords2Vec()函数，输入参数为词汇表以及某个切分后的文档，输出是文档向量，向量的每一元素为1或0，分别表示词汇表中的单词在文档中是否出现，出现为1。

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

• 伪代码：

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

对每篇训练文档：

    对每个类别：

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

        增加所有词条的计数值

对每个类别：

    对每个词条：

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

返回每个类别的条件概率

# 训练朴素贝叶斯算法，trainMatrix 文档矩阵；trainCategory 文档类别标签所构成的向量
def trainNB0(trainMatrix, trainCategory):
    # 计算文档数目和第一个文档中词条数
    numTrainDocs = len(trainMatrix)
    numWords = len(trainMatrix[0])
    # 求在训练集中任取一个文档是侮辱性（trainCategory=1）的概率
    pAbusive = sum(trainCategory) / float(numTrainDocs)
    # 初始化，没有用p0Num = zeros(numWords)，是为了避免某一个概率值为0，
    # 使得最后的乘积也是0，即使变成log()，log(0)也是不对的
    p0Num = ones(numWords)
    p1Num = ones(numWords)
    # 相应地 p0Denom = 0.0 修改为 p0Denom = 2.0
    p0Denom = 2.0
    p1Denom = 2.0
    for i in range(numTrainDocs):
        # 如果是侮辱性言论，
        if trainCategory[i] == 1:
            # 把当前文档的词条向量加到p1Num上，p1Num：侮辱性言论中每个单词出现次数
            p1Num += trainMatrix[i]
            # p1Denom：侮辱性言论中总单词数
            p1Denom += sum(trainMatrix[i])
        # 非侮辱性
        else:
            # 把当前文档的词条向量加到p0Num上，p0Num：非侮辱性言论中每个单词出现次数
            p0Num += trainMatrix[i]
            # p0Denom：非侮辱性言论中总单词数
            p0Denom += sum(trainMatrix[i])
    # 对每个元素做除法（log把乘变成加避免下溢出）
    p1Vect = log(p1Num / p1Denom)
    # print(p1Vect)
    p0Vect = log(p0Num / p0Denom)
    # print(p0Vect)
    # lineplot(p0Num, p0Vect)
    return p0Vect, p1Vect, pAbusive


def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    # p1：是侮辱性文档的概率，对每一个单词累加log()概率
    p1 = sum(vec2Classify * p1Vec) + log(pClass1)
    # p0：是非侮辱性文档的概率
    p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
    # 如果p1 > p0，侮辱性文档，反之，非
    if p1 > p0:
        return 1
    else:
        return 0

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

# 字符串拆分、小写、去除长度小于3的
def textParse(bigString):
    listOfTokens = re.split('\w+', bigString)
    return [tok.lower() for tok in listOfTokens if len(tok) > 2]


# spamTest():
def spamTest():
    docList = []
    classList = []
    fullList = []
    for i in range(1, 26):
        # 把spam（垃圾邮件）文件夹下的文本加入到docList、fullList中
        wordList = textParse(open('email/spam/%d.txt' % i).read())
        docList.append(wordList)
        fullList.extend(wordList)
        # 垃圾邮件类别为1，calssList加入1
        classList.append(1)
        # 把ham（非垃圾邮件）文件夹下的文本加入到docList、fullList中
        wordList = textParse(open('email/ham/%d.txt' % i, encoding='gb18030', errors='ignore').read())
        docList.append(wordList)
        fullList.extend(wordList)
        # 垃圾邮件类别为0，calssList加入0
        classList.append(0)
    # 根据输入的文档生成包含文档中所有单词的词汇表
    vocabList = bayes.createVocabList(docList)
    # 生成长度为50的列表，元素值为0-49，用作docList列表的索引
    trainingSet = list(range(50))
    # 声明testSet列表
    testSet = []

    # 在trainingSet中任取10个不重复数据的索引加入到测试及
    for i in range(10):
        randIndex = int(random.uniform(0, len(trainingSet)))
        # 把索引对应的trainingSet中的值加入到testSet中
        testSet.append(trainingSet[randIndex])
        # 删除加入到testSet中的索引
        del trainingSet[randIndex]
    # 声明trainMat(训练数据集)、trainClasses(训练数据集的分类列表)
    trainMat = []
    trainClasses = []
    # 给训练数据集、trainClasses添加数据
    for docIndex in trainingSet:
        trainMat.append(bayes.setOfWords2Vec(vocabList, docList[docIndex]))
        trainClasses.append(classList[docIndex])
    # 调用训练算法进行训练
    p0V, p1V, pSpam = bayes.trainNB0(array(trainMat), array(trainClasses))
    # 使用测试数据集测试训练后的算法的错误率
    errorCount = 0
    for docIndex in testSet:
        # 对于测试数据，求每一个文档的词条向量
        wordVector = bayes.setOfWords2Vec(vocabList, docList[docIndex])
        # 对每一个词条向量分类并与真实分类进行比较计算错误率
        if bayes.classifyNB(array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:
            errorCount += 1
    print('the error rate is:', float(errorCount) / len(testSet))

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

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

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

我们将分别从美国的两个城市中选取一些人， 通过分析这些人发布的征婚广告信息，来比较两个城市的人们在广告用词上是否不同。

2.1 收集数据：导入RSS源

需要feedparse包来作为RSS阅读器

2.2 测试算法

# 返回出现频率最高的30个词
def calcMostFreq(vocabList, fullText):
    freqDict = {}
    for token in vocabList:
        freqDict[token] = fullText.count(token)
    sortedFreq = sorted(freqDict.items(), key=operator.itemgetter(1), reverse=True)
    return sortedFreq[:30]


# 加载数据，计算贝叶斯的错误率
def localWords(feed1, feed0):
    docList = []
    classList = []
    fullText = []
    minLen = min(len(feed1['entries']), len(feed0['entries']))
    for i in range(minLen):
        wordList = textParse(feed1['entries'][i]['summary'])
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1)
        wordList = textParse(feed0['entries'][i]['summary'])
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)
    vocabList = createVocabList(docList)
    # 获取出现频率最高的30个词
    top30Words = calcMostFreq(vocabList, fullText)
    # 去掉出现次数最高的30个词，语言中大部分都是冗余和结构辅助性内容，
    # 即出现次数多的中有大量的停用词
    for pairW in top30Words:
        if pairW[0] in vocabList:
            vocabList.remove(pairW[0])
    trainingSet = list(range(2 * minLen))
    testSet = []
    # 任取20条数据的索引加入到测试数据集中
    for i in range(20):
        randIndex = int(random.uniform(0, len(trainingSet)))
        testSet.append(trainingSet[randIndex])
        del trainingSet[randIndex]
    # 构造训练数据集
    trainMat = []
    trainClasses = []
    for docIndex in trainingSet:
        # 词袋模型
        trainMat.append(bagOfWord2VecMN(vocabList, docList[docIndex]))
        trainClasses.append(classList[docIndex])

    # 训练算法
    p0V, p1V, pSpam = trainNB0(array(trainMat), array(trainClasses))
    # 初始化错误率，并计算算法错误率
    errorCount = 0
    for docIndex in testSet:
        wordVector = bagOfWord2VecMN(vocabList, docList[docIndex])
        if classifyNB(array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:
            errorCount += 1
    print('the error rate is : ', float(errorCount) / len(testSet))
    return vocabList, p0V, p1V


# 测试
ny = feedparser.parse('http://newyork.craigslist.org/stp/index.rss')
sf = feedparser.parse('http://sfbay.craigslist.org/stp/index.rss')
vocablist, psf, pny = localWords(ny, sf)

loacalWords()使用两个RSS源作为参数。RSS源要在函数外导入，这样做的原因是RSS源会随时间而改变。