机器学习之贝叶斯分类

亦凉 2023-06-02 15:58 2阅读 0赞

**必要的数学概念**：

**1.条件概率**：

![1624355-20190816162308450-120321398.png][]

![1624355-20190816105610919-1007306863.png][]

条件概率公式的含义是计算A在B发生的条件下的概率，即 P（A|B）=  P（A∩B）/ P（B）

于是就可以进行以下推导：

P（A|B）=  P（A∩B）/P（B），同理  P（B|A）=  P（A∩B）/P（A）

于是： P（A∩B）=P（A|B）\*P（B）=P（A）\*  P（B|A）

于是就可以使用P（A）\*  P（B|A）替换P（A∩B），从而得出P（A|B）=P（B|A）\*P(A) / P（B）。

2.**全概率公式**：

![1624355-20190816152953006-468852434.png][]

推导过程如下：首先样本空间S=A+A'

![1624355-20190816153121533-1779118790.png][]

上述文氏图可以写出以下表达式：P（B）=P(B∩A)+P(B∩A')  ①

在条件概率中我们得出：P（A∩B）=P（A|B）\*P（B）=P（A）\*  P（B|A)  ②

将②带入①得到：P（B）=P（B|A）\*P（A）+P（B|A'）\*P（A'）  ③

将③式带入条件概率公式替换P（B）就得到了全概率公式。

**贝叶斯决策：**p1(特征)>p0(特征)，即某特征1类别的概率大于0类别是，就认为该特征下，属于1类别，结果为1类。

**朴素贝叶斯推断**：每个特征独立，于是可以特征X集拆分成x1...xn

![1624355-20190816162556526-744357829.png][]

于是对于下面举例的数据集（前两项为特征，最后一项为结果）可以按以下过程计算

![1624355-20190816162957656-699139251.png][]

因为![1624355-20190816163036802-2066631446.png][]

所以 ![1624355-20190816163315258-700697985.png][]

## 算法实现 ##

机器学习实战教程中的思路是：构建词向量（文字变数字）-->训练算法、分类

算法的核心就是计算每个特征 分别在不同类别下的概率。

**1.构建词向量**

导入库：

import numpy as np

1.1 定义训练集文本

1 def loadDataSet():  #定义训练集的文本及标签
    2   postingList = [['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],  # 切分的词条
    3                  ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
    4                  ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
    5                  ['stop', 'posting', 'stupid', 'worthless', 'garbage'],
    6                  ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
    7                  ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]
    8   classVec = [0, 1, 0, 1, 0, 1]  # 类别标签向量，1代表侮辱性词汇，0代表不是
    9   return postingList, classVec

1.2 创建词汇表（将重复的词汇，变成一个不重复的序列）

#传入参数：dataset：训练集
    1 def createVocabList(dataSet): 
    2   vocabSet = set([])  # 创建一个空的不重复列表
    3   for document in dataSet:
    4     vocabSet = vocabSet | set(document)  # 取并集，获得所有的词汇并且这些词汇不重复
    5   return list(vocabSet)

1.3 构建词向量：与词汇表长度一致的数字序列，用来定位词汇位置（具体一点就是语句中的词汇在词汇表中的位置）

词向量矩阵：可以表示出训练集一句话中每个词在词汇表中的位置，词向量的行定位到语句，词向量的列定位到该词语在词汇表中的位置。

这样也就明白了为什么要创建词汇表，就是为了去重复然后实现词汇定位的。

# 传入参数：vocabList：词汇表, inputSet：训练集中的一句话

def setOfWords2Vec(vocabList, inputSet):
      returnVec = [0] * len(vocabList)  # 创建一个其中所含元素都为0的向量，初始化词向量
      for word in inputSet:  # 遍历每个词条
        if word in vocabList:  # 如果词条存在于词汇表中，则词向量表该位置变为1,
          returnVec[vocabList.index(word)] = 1 #list.index是列表的取索引方法，这种定义方法改变了原始的词汇表，从而完成定位的任务
        else:
          print("the word: %s is not in my Vocabulary!" % word)
      return returnVec  # 返回文档向量

**2.训练算法**

贝叶斯算法是要利用条件概率来判定每个特征所属的类别，于是完成上述步诹后就要进行数学计算了

在这个实例中是判定一个词是否属于侮辱性词，所以计算公式为：P（侮辱性类别1|词汇 i）=P（词汇 i  |侮辱性类别1）\*P(侮辱性类别1) / P（词汇 i ）

2.1

①计算每个词汇属于侮辱或者正常类型的概率，P（词汇 i  |侮辱性类别）= 词汇i 分别在两个类别中出现次数 / 两个类别中的的词汇总数

②计算侮辱性类别的概率：P(侮辱性类别1）=训练集中侮辱性语句的数量 / 训练集语句总数

1 def trainNB0(trainMatrix, trainCategory): #trainMatrix为词向量矩阵，trainCategory训练集标签
     2   numTrainDocs = len(trainMatrix)  # 计算训练的语句数目，
     3   numWords = len(trainMatrix[0])  # 词向量总数，或者说整个训练集词汇总数（不重复的）
     4   pAbusive = sum(trainCategory) / float(numTrainDocs)  # 文档属于侮辱类的概率
     5   p0Num = np.zeros(numWords); #p0Num、p1Num用于计数，每个词在0/1类别中分别出现的次数，一次是一个序列
     6   p1Num = np.zeros(numWords)  # 创建numpy.zeros数组,词条出现数初始化为0
     7   p0Denom = 0.0;
     8   p1Denom = 0.0  #p0Denom、p1Denom用于统计0/1类别中各自出现的词汇总数
     9   for i in range(numTrainDocs): #遍历训练集的每个语句
    10     if trainCategory[i] == 1:  #根据语句的标签，分别统计语句中各词汇的次数、该类别下出现的总的词汇数量
    11 
    12       p1Num += trainMatrix[i] #利用索引，定位到该语句对应的词向量，由于词向量是用于定位每个词在词汇表的位置的，所以与初始化序列求和可统计次数
    13       p1Denom += sum(trainMatrix[i]) #词向量1表示该语句的词在词向量中的位置，所以求和可得该语句词汇总数
    14 
    15     else:  # 统计属于非侮辱类的条件概率所需的数据
    16       p0Num += trainMatrix[i]
    17       p0Denom += sum(trainMatrix[i])
    18   p1Vect = p1Num / p1Denom #可得每个词属于该类别的概率（先验概率），可用log（）
    19   p0Vect = p0Num / p0Denom20   return p0Vect, p1Vect, pAbusive  # 返回属于侮辱类的条件概率数组，属于非侮辱类的条件概率数组，文档属于侮辱类的概率

**注意**：上述计算代码中，为了抵消0\*任何数为0的情况，我们可以初始化p0Num=np.ones()、p1Num=np.ones()、p0Demon=2、p1Demon=2，同时为了防止数值太小向下溢出，可以用log（p0Num/p0Demon）代替p0Num/p0Demon

2.2利用上步所得的概率进行计算分类

我们已经知道了每个词在不同类别中的概率，那我们测试的时候只需将 测试集词向量\*词汇概率数组，然后对该数组求和，就可以得到测试集存在的词汇属于该类别的整体概率了，最后比较一下哪种类别的可能性最大，就选哪种

#参数vec2Classify：测试集的词向量，p0Vec, p1Vec词汇的先验概率数组，pClass1分类1（侮辱性）的概率
     def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
         p1 = sum(vec2Classify * p1Vec) + np.log(pClass1)        #对应元素相乘。logA * B = logA + logB，所以这里加上log(pClass1)

p0 = sum(vec2Classify * p0Vec) + np.log(1.0 - pClass1)4     
    
    　　　print('p0:',p0)
         print('p1:',p1)
         if p1 > p0:
             return 1
         else: 
             return 0

2.3测试算法

1 def testingNB():
     2     listOPosts,listClasses = loadDataSet()                                    #创建实验样本
     3     myVocabList = createVocabList(listOPosts)                                #创建词汇表
     4     trainMat=[]
     5     for postinDoc in listOPosts:
     6         trainMat.append(setOfWords2Vec(myVocabList, postinDoc))                #将实验样本向量化
     7     p0V,p1V,pAb = trainNB0(np.array(trainMat),np.array(listClasses))        #训练朴素贝叶斯分类器
     8     testEntry = ['love', 'my', 'dalmation']                                    #测试样本1
     9     thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))                #测试样本向量化
    10     if classifyNB(thisDoc,p0V,p1V,pAb):
    11         print(testEntry,'属于侮辱类')                                        #执行分类并打印分类结果
    12     else:
    13         print(testEntry,'属于非侮辱类')                                        #执行分类并打印分类结果
    14     testEntry = ['stupid', 'garbage']                                        #测试样本2
    15 
    16     thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))                #测试样本向量化
    17     if classifyNB(thisDoc,p0V,p1V,pAb):
    18         print(testEntry,'属于侮辱类')                                        #执行分类并打印分类结果
    19     else:
    20         print(testEntry,'属于非侮辱类')                                        #执行分类并打印分类结果

**3.实战**

上面1与2是算法的核心，具体到时间中还需要一些其他的操作才能完成

3.1 导入文本切割字2符

#英文字符切割
    1 import re
    2 def textParse(bigString):                     #将字符串转换为字符列表
    3     listOfTokens = re.split(r'\W+', bigString)      #\w表示匹配非单词字符，将其作为切分标志进行字符串切分，即非字母、非数字
    4     return [tok.lower() for tok in listOfTokens if len(tok) > 2]      #返回一个列表，利用列表表达式使得单词全部是小写，执行从for开始，相当于for..if..tok.lower()#中文字符切割，使用jieba库分割import jieba

\#中文字符切割 使用第三方库jieba  
import jieba  
jieba.cut(字符串, cut\_all=True) \#cut\_all=True为全模式、false为精简模式，返回一个生成器  
 \#文档：https://github.com/fxsjy/jieba

3.2交叉验证

1 def spamTest():#设置交叉验证（好像看上去只是划分测试集，没看到交叉验证）：读取文本 -> 随机划分文本为训练集和测试集 ->训练、测试、计算错误率
     2   docList = [];
     3   classList = [];
     4   fullText = []
     5   for i in range(1, 26):  # 遍历25个txt文件
     6     wordList = textParse(open('email/spam/%d.txt' % i, 'r').read())  # 读取每个垃圾邮件，并字符串转换成字符串列表
     7     docList.append(wordList)
     8     fullText.append(wordList)
     9     classList.append(1)  # 标记垃圾邮件，1表示垃圾文件
    10     wordList = textParse(open('email/ham/%d.txt' % i, 'r').read())  # 读取每个非垃圾邮件，并字符串转换成字符串列表
    11     docList.append(wordList)
    12     fullText.append(wordList)
    13     classList.append(0)  # 标记非垃圾邮件，1表示垃圾文件
    14   vocabList = createVocabList(docList)  # 创建词汇表，不重复
    15   trainingSet = list(range(50));
    16   testSet = []  # 创建存储训练集的索引值的列表和测试集的索引值的列表
    17   for i in range(10):  # 从50个邮件中，随机挑选出40个作为训练集,10个做测试集
    18     randIndex = int(random.uniform(0, len(trainingSet)))  # 随机选取索索引值，需要import random
    19     testSet.append(trainingSet[randIndex])  # 添加测试集的索引值
    20     del (trainingSet[randIndex])  # 在训练集列表中删除添加到测试集的索引值
    21   trainMat = [];
    22   trainClasses = []  # 创建训练集矩阵和训练集类别标签系向量
    23   for docIndex in trainingSet:  # 遍历训练集
    24     trainMat.append(setOfWords2Vec(vocabList, docList[docIndex]))  # 将生成的词集模型添加到训练矩阵中
    25     trainClasses.append(classList[docIndex])  # 将类别添加到训练集类别标签系向量中
    26   p0V, p1V, pSpam = trainNB0(np.array(trainMat), np.array(trainClasses))  # 训练朴素贝叶斯模型
    27   errorCount = 0  # 错误分类计数
    28   for docIndex in testSet:  # 遍历测试集
    29     wordVector = setOfWords2Vec(vocabList, docList[docIndex])  # 测试集的词集模型
    30     if classifyNB(np.array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:  # 如果分类错误
    31       errorCount += 1  # 错误计数加1
    32       print("分类错误的测试集：", docList[docIndex])
    33   print('错误率：%.2f%%' % (float(errorCount) / len(testSet) * 100))

3.3 实战教程上关于使用贝叶斯过滤垃圾邮件的完整代码

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

import numpy as np
    import random
    import re
    
    def createVocabList(dataSet):
      vocabSet = set([])  # 创建一个空的不重复列表
      for document in dataSet:
        vocabSet = vocabSet | set(document)  # 取并集
      return list(vocabSet)
    
    def setOfWords2Vec(vocabList, inputSet):
      returnVec = [0] * len(vocabList)  # 创建一个其中所含元素都为0的向量
      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  # 返回文档向量
    
    def bagOfWords2VecMN(vocabList, inputSet):
      returnVec = [0] * len(vocabList)  # 创建一个其中所含元素都为0的向量
      for word in inputSet:  # 遍历每个词条
        if word in vocabList:  # 如果词条存在于词汇表中，则计数加一
          returnVec[vocabList.index(word)] += 1
      return returnVec  # 返回词袋模型
    
    def trainNB0(trainMatrix, trainCategory):
      numTrainDocs = len(trainMatrix)  # 计算训练的文档数目
      numWords = len(trainMatrix[0])  # 计算每篇文档的词条数
      pAbusive = sum(trainCategory) / float(numTrainDocs)  # 文档属于侮辱类的概率
      p0Num = np.ones(numWords);
      p1Num = np.ones(numWords)  # 创建numpy.ones数组,词条出现数初始化为1，拉普拉斯平滑
      p0Denom = 2.0;
      p1Denom = 2.0  # 分母初始化为2,拉普拉斯平滑
      for i in range(numTrainDocs):
        if trainCategory[i] == 1:  # 统计属于侮辱类的条件概率所需的数据，即P(w0|1),P(w1|1),P(w2|1)···
          p1Num += trainMatrix[i]
          p1Denom += sum(trainMatrix[i])
        else:  # 统计属于非侮辱类的条件概率所需的数据，即P(w0|0),P(w1|0),P(w2|0)···
          p0Num += trainMatrix[i]
          p0Denom += sum(trainMatrix[i])
      p1Vect = np.log(p1Num / p1Denom)  # 取对数，防止下溢出
      p0Vect = np.log(p0Num / p0Denom)
      return p0Vect, p1Vect, pAbusive  # 返回属于侮辱类的条件概率数组，属于非侮辱类的条件概率数组，文档属于侮辱类的概率
    
    
    def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
      p1 = sum(vec2Classify * p1Vec) + np.log(pClass1)  # 对应元素相乘。logA * B = logA + logB，所以这里加上log(pClass1)
      p0 = sum(vec2Classify * p0Vec) + np.log(1.0 - pClass1)
      if p1 > p0:
        return 1
      else:
        return 0
    
    def textParse(bigString):  # 将字符串转换为字符列表
      listOfTokens = re.split(r'\W*', bigString)  # 将特殊符号作为切分标志进行字符串切分，即非字母、非数字
      return [tok.lower() for tok in listOfTokens if len(tok) > 2]  # 除了单个字母，例如大写的I，其它单词变成小写
    
    def spamTest():
      docList = [];
      classList = [];
      fullText = []
      for i in range(1, 26):  # 遍历25个txt文件
        wordList = textParse(open('email/spam/%d.txt' % i, 'r').read())  # 读取每个垃圾邮件，并字符串转换成字符串列表
        docList.append(wordList)
        fullText.append(wordList)
        classList.append(1)  # 标记垃圾邮件，1表示垃圾文件
        wordList = textParse(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))
    
    
    if __name__ == '__main__':
      spamTest()

**python语法：**

reduce（）函数语法：reduce(function, iterable\[, initializer\]) ；reduce函数会对可迭代对象 迭代运用函数，最后是一个值

random.uniform(a,b) 选择一个ab间的随机数

** 未完待改。。。**

转载于:https://www.cnblogs.com/jacker2019/p/11362661.html

[1624355-20190816162308450-120321398.png]: /images/20230601/b772d5cb9d364f05ab399c23867162b3.png
[1624355-20190816105610919-1007306863.png]: /images/20230601/b20eb05c71444b15928d6b5e00eb2446.png
[1624355-20190816152953006-468852434.png]: /images/20230601/7374ea77605a40b792b204b93ed80d0b.png
[1624355-20190816153121533-1779118790.png]: /images/20230601/bdb7387659dc4e65b4ce93125e47f400.png
[1624355-20190816162556526-744357829.png]: /images/20230601/9b8e467ba6174fb7b7d2ae8fb0537e2b.png
[1624355-20190816162957656-699139251.png]: /images/20230601/9f894abce14943aaa4e7171aaab998c7.png
[1624355-20190816163036802-2066631446.png]: /images/20230601/ab8deb65517748c1a9adbd5e2c3f3ca2.png
[1624355-20190816163315258-700697985.png]: /images/20230601/d8ab6ebf87e44855882dc68c5519c968.png
[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20230601/45b8e84263974bfa896edf6e1935b1a0.png