机器学习第四章 朴素贝叶斯

第四章 基于概率论的分类方法：朴素贝叶斯

1.基本概念

• 朴素贝叶斯：也是一种分类方法，本质上是为测试的数据从多个样本标签中选择概率最高的的一个作为它的标签。比如，测试的数据D类别有$p_1(x,y)$,$p_2(x,y)$两种可能，但计算的结果是前者大于后者，那么D的类别会判定为$p_1(x,y)$。

• 贝叶斯准则：已知事件B发生的条件下，求事件A发生的概率，表达如式1
  $$P(A|B)=\frac{P(B|A)\ast P(A)}{P(B)}\text{\hspace{1em}(1)}$$
  贝叶斯引入“先验概率”和逻辑推理 来处理不确定命题，式1中，几个计算因子有各自对应的逻辑含义

  算子	名称	作用
  P(A)	先验概率	在事件B发生前，得出事件A发生的概率
  P(A|B)	后验概率	在事件B发生后，事件A发生的概率可能发生改变
  P(B|A)/P(B)	可能性函数（调整因子）	能够影响先验概率的大小

  想细讲一下调整因子，在贝叶斯统计中，调整因子是指根据新的观测数据来更新先验概率，得到后验概率的过程中所乘的一个因子。举个例子：假设一种传染病的发病率为10%，专业团队研发出它的一种抗原，用在正常人身上，准确率为95%，而用在患者身上，准确率为99%。根据贝叶斯准则，有这么个关系式：P(患病|阳性) = P(患病) * [(P(阳性|患病) / P(阳性)]。假设我们发现，这个传染病在0到10岁的小孩里，患病率是5%，那么先验概率P(患病)就会从1%提升到5%，从而影响后验概率的计算。

  总之，调整因子的作用是根据新的观测数据来修正我们对事件的概率的预测，使其更接近真实情况。

  式1有个推导（式2），针对大量样本的情况
  $$P(c_i|x,y)=\frac{p(x,y|c_i)P(c_i)}{P(x,y)}\text{\hspace{1em}(2)}$$

2.应用

• 用朴素贝叶斯原理做文本分类，以书上“判断在线留言板是否有侮辱性言论”为例
  首先需要准备数据：因为只是社区里的留言板，流量不会太大，可以先统计3天内用户的发言，将用户发表的内容分割成单个词汇，以列表元素的形式进行存储，并为这些词汇贴上标签，比如：标签为1表示侮辱性词汇，为0则表示非侮辱性词汇

  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 word in dataSet:
      vocabSet = vocabSet | set(word)
      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
  if __name__ == '__main__':
      postingList, classVec = loadDataSet()  # 原始词条
      print('postingList:\n', postingList)
      myVocabList = createVocabList(postingList)
      print("my vocabulary is:\n", myVocabList)
      trainMat = []
      for postinDoc in postingList:
          trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
      p0V,p1V,pAb = trainNB0(trainMat,classVec)
      print('trainMat:\n', trainMat)
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32

​ postingList表示切割后的用户发言集合，classVec表示单个词汇对应的标签；根据 postingList集合的词汇生成一个不含重复元素的词汇表vocabList；最后，根据词汇表制作“词条向量”，可以理解为，在原本的postingList中，如果词汇表中的某个词汇在列表postingList中出现一次，则在指定位置记1，未出现则记为0

​ 朴素贝叶斯分类器训练函数：用词条向量计算概率

​ 在准备数据阶段，我们已经把词汇“转为”数字，现在要做的，就是计算出列表元素时侮辱性词汇和非侮辱性词汇的概率

def trainNB0(trainMatrix, trainCategory):
    import numpy as np
    # 计算训练文档的列表数目
    numTrainDocs = len(trainMatrix)
    # 计算文档的总词条数目
    numWords = len(trainMatrix[0])
    # 判断文档属于侮辱类的的概率
    pAbusive = sum(trainCategory) / float(numTrainDocs)
    p0Num = np.zeros(numWords)
    p1Num = np.zeros(numWords)
    p0Denom = 0.0
    p1Denom = 0.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 = p1Num / p1Denom
    p0Vect = p0Num / p0Denom
    return p0Vect, p1Vect, pAbusive
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

可以看见，help这样的褒义词汇是非侮辱性词汇的概率是4.17%，是侮辱性词汇的概率是0；文档有侮辱性词汇概率为1/2，符合一开始的设定（五五开）。再使用贝叶斯分类器对文档进行分类时，判断一个文档属于哪个类别需要计算多个概率相乘的结果$P(w_0|1)P(w_1|1)...P(w_n|1)$，算子当中可能存在许多很小的数，相乘之后可能导致下溢（比如多次相乘+四舍五入之后结果变成0）。为了避免这种情况影响结果，可以考虑对每个算子$f(x)$取自然对数$ln(f(x))$，算子在处理前后的变化趋势发生改变，但变化的方向不变，在同一个点取得极值，因此不会影响对最终结果的判定

• 书上第二个例子：过滤垃圾电子邮件
  实验步骤：
  1.收集数据：下载书上给的txt英文数据集，内含正经邮件和广告垃圾邮件
  2.准备数据：每封邮件的内容以非字母、非数字符号作为切割信号，比如Hello jeff!会被拆分为Hello和jeff两个词。为了防止字符串里的标点符号并入词汇部分，使用正则表达式对齐进行分割，并且仅返回长度超过1的词汇

def textSplit(string):
    listOfTokens = re.split(r'\W+', string)
    return [tok.lower() for tok in listOfTokens if len(tok) >= 2]
if __name__ == '__main__':
  words = textSplit("hello my name is jeff")
  print(words)
1
2
3
4
5
6

3.分析数据：看看之前拆分的词汇有没有问题，或者导入的编码格式是否有误
4.训练算法：使用之前建立的trainNB0()函数
5.测试算法：创建classifyNB()函数，用它计算文档集中的错误率

def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
   p1 = sum(vec2Classify * p1Vec) + np.log(pClass1)
   p0 = sum(vec2Classify * p0Vec) + np.log(1.0 - pClass1)
   if p1 > p0:
       return 1
   else:
       return 0
1
2
3
4
5
6
7

6.使用算法：直接实战，显示算法错误率

def spamTest():
    docList = []
    classList = []
    fullText = []
    for i in range(1, 26):  # 遍历25个txt文件
        wordList = textSplit(open('email/spam/%d.txt' % i, 'r').read())  # 读取每个垃圾邮件，并字符串转换成字符串列表
        docList.append(wordList)
        fullText.append(wordList)
        classList.append(1)  # 标记垃圾邮件，1表示垃圾文件

        wordList = textSplit(open('email/ham/%d.txt' % i, 'r').read())  # 读取每个非垃圾邮件，并字符串转换成字符串列表
        docList.append(wordList)
        fullText.append(wordList)
        classList.append(0)  # 标记非垃圾邮件，1表示垃圾文件
    vocabList = createVocabList(docList)  # 创建词汇表，不重复
    trainingSet = list(range(50))
    testSet = []  # 创建存储训练集的索引值的列表和测试集的索引值的列表
    for i in range(10):  # 从50个邮件中，随机挑选出40个作为训练集,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(np.array(trainMat), np.array(trainClasses))  # 训练朴素贝叶斯模型
    errorCount = 0  # 错误分类计数
    for docIndex in testSet:  # 遍历测试集
        wordVector = setOfWords2Vec(vocabList, docList[docIndex])  # 测试集的词集模型
        if classifyNB(np.array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:  # 如果分类错误
            errorCount += 1  # 错误计数加1
            print("分类错误的测试集：", docList[docIndex])
    print('错误率：%.2f%%' % (float(errorCount) / len(testSet) * 100))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

导入文件夹spam和ham（分别为两个类型的文本文件夹），将他们解析为词向量之后，利用其中随机40个文本作为训练集，随机10个文本作为测试集来计算错误率，为了提高测试精度，我们设定，已作为训练集的文本不会再加入测试集文本这个序列。测试了10次左右，错误率基本在0%~20%内

• 英文邮件好办，用split函数结合正则表达式就可以过滤掉大部分无用信息。如果我们需要处理中文邮件，那么可以考虑用jieba这个插件

  def TextProcess(path):
      with open(os.path.join(path), encoding='utf-8') as f: 
          raw = f.read()
      word_cut = jieba.cut(raw, cut_all=False)  
      word_list = list(word_cut) 
      print(word_list)
  1
  2
  3
  4
  5
  6

中文的分割实现了，不过邮件里的标点符号也会一同导入到列表中，尝试用正则表达式处理，但是效果不太好，有些字符没法过滤掉

3.小结

之前学到的k-NN算法、决策树算法也都是需要把数据集样本的标签做数字化处理，前者通过计算样本集与测试集的点距离获得结果；后者则倾向于得出信息增益最大的特征，再选择最佳的几个特征作为判断标准；而朴素贝叶斯比较特别一些，用概率统计的方式得出测试数据最可能的类别。假设一个特征需要N个样本才能准确标示，那么10个特征就需要$N^{1000}$个样本，如果这些特征是独立的，那么就只需要$1000\times N$个样本。如果样本的特征相互独立，采用朴素贝叶斯进行预测的话，样本的数量要求就没那么高，