基于贝叶斯决策理论的分类方法

快来打我* 2021-11-27 07:16 264阅读 0赞

### 基于贝叶斯决策理论的分类方法 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">朴素贝叶斯</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">优点：在数据较少的情况下仍然有效，可以处理多类别问题。</td> 
  </tr> 
  <tr> 
   <td align="left">缺点：对于输入数据的准备方式较为敏感。</td> 
  </tr> 
  <tr> 
   <td align="left">适用数据类型：标称型数据。</td> 
  </tr> 
 </tbody> 
</table>

假设现在我们有一个数据集，它由两类数据组成

![aHR0cHM6Ly93czEuc2luYWltZy5jbi9sYXJnZS8wMDZReW4yUWx5MWc1OWt1amQ4eGdqMzBuaTBpOHRmYS5qcGc][]

p1(x,y)表示数据点(x,y)属于类别1（图中用圆点表示的类别）的概率 ,用p2(x,y)表示数据点(x,y)属于类别2（图中用三角形表示的类别）的概率

对于一个新数据点(x,y) ,如果 p1(x,y) > p2(x,y)，那么类别为1 ,如果 p2(x,y) > p1(x,y)，那么类别为2

> 也就是说，我们会选择高概率对应的类别。这就是贝叶斯决策理论的核心思想，即选择具有最高概率的决策。

### 条件概率 ###

> 条件概率的计算公式如下所示：

P (  gray  ∣  bucket  B ) = P (  gray and bucketB)  / P (  bucket  B ) \\mathrm\{P\}(\\text \{ gray \} | \\text \{ bucket \} \\mathrm\{B\})=\\mathrm\{P\}(\\text \{ gray and bucketB) \} / \\mathrm\{P\}(\\text \{ bucket \} \\mathrm\{B\}) P( gray ∣ bucket B)=P( gray and bucketB) /P( bucket B)

> 另一种有效计算条件概率的方法称为贝叶斯准则 ,即如果已知P(x|c)，要求P(c|x)

p ( c ∣ x ) = p ( x ∣ c ) p ( c ) p ( x ) p(c | x)=\\frac\{p(x | c) p(c)\}\{p(x)\} p(c∣x)=p(x)p(x∣c)p(c)

### 使用条件概率来分类 ###

前面提到贝叶斯决策理论要求计算两个概率p1(x, y)和p2(x, y)

使用p1( )和p2( )只是为了尽可能简化描述，而真正需要计算和比较的是p(c1|x, y)和p(c2|x, y)。这些符号所代表的具体意义是：给定某个由x、 y表示的数据点，那么该数据点来自类别c1的概率是多少？

> 应用贝叶斯准则得到

p ( c i ∣ x , y ) = p ( x , y ∣ c i ) p ( c i ) p ( x , y ) p\\left(c\_\{i\} | x, y\\right)=\\frac\{p\\left(x, y | c\_\{i\}\\right) p\\left(c\_\{i\}\\right)\}\{p(x, y)\} p(ci∣x,y)=p(x,y)p(x,y∣ci)p(ci)

 如果P(c1|x, y) > P(c2|x, y)，那么属于类别c1。  
 如果P(c1|x, y) < P(c2|x, y)，那么属于类别c2。

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

机器学习的一个重要应用就是文档的自动分类。在文档分类中，整个文档（如一封电子邮件）是实例，而电子邮件中的某些元素则构成特征。 朴素贝叶斯是上节介绍的贝叶斯分类器的一个扩展，是用于文档分类的常用算法。

<table> 
 <thead> 
  <tr> 
   <th>朴素贝叶斯的一般过程</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>(1) 收集数据：可以使用任何方法。本章使用RSS源。</td> 
  </tr> 
  <tr> 
   <td>(2) 准备数据：需要数值型或者布尔型数据。</td> 
  </tr> 
  <tr> 
   <td>(3) 分析数据：有大量特征时，绘制特征作用不大，此时使用直方图效果更好。</td> 
  </tr> 
  <tr> 
   <td>(4) 训练算法：计算不同的独立特征的条件概率。</td> 
  </tr> 
  <tr> 
   <td>(5) 测试算法：计算错误率。</td> 
  </tr> 
  <tr> 
   <td>(6) 使用算法：一个常见的朴素贝叶斯应用是文档分类。可以在任意的分类场景中使用朴 素贝叶斯分类器，不一定非要是文本。</td> 
  </tr> 
 </tbody> 
</table>

要得到好的概率分布，就需要足够的数据样本，假定样本数为N。 由统计学知，如果每个特征需要N个样本，那么对于10个特征将需要 N 10 N^\{10\} N10个样本，对于包含1000个特征的词汇表将需要 N 1000  N^\{1000\} N1000个样本。可以看到，所需要的样本数会随着特征数目增大而迅速增长

如果特征之间相互独立，那么样本数就可以从 N 1000  N^\{1000\} N1000减少到1000×N。所谓独立（independence）指的是统计意义上的独立，即一个特征或者单词出现的可能性与它和其他单词相邻没有关系。

### 使用 Python 进行文本分类 ###

要从文本中获取特征，需要先拆分文本。 这里的特征是来自文本的词条（token），一个词条是字符的任意组合。可以把词条想象为单词，也可以使用非单词词条，如URL、IP地址或者任意其他字符串。然后将每一个文本片段表示为一个词条向量，其中值为1表示词条出现在文档中， 0表示词条未出现。

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

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

我们将把文本看成单词向量或者词条向量，也就是说将句子转换为向量。考虑出现在所有文档中的所有单词，再决定将哪些词纳入词汇表或者说所要的词汇集合，然后必须要将每一篇文档转换为词汇表上的向量。

> 词表到向量的转换函数

# 加载数据集函数
    def loadDataSet():
        # 定义邮件列表
        postingList = [['my', 'dog', 'has', 'flea', \
                        'problem', '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']]
        # 定义标签向量，1——abusive，0——not abusive,1 代表侮辱性文字， 0代表正常言论
        classVec = [0, 1, 0, 1, 0, 1]
        return postingList, classVec

`loadDataSet()`创建了一些实验样本。该函数返回的第一个变量是进行词条切分后的文档集合, `loadDataSet( )`函数返回的第二个变量是一个类别标签的集合。这里有两类，侮辱性和非侮辱性。这些文本的类别由人工标注，这些标注信息用于训练程序以便自动检测侮辱性留言。

# 创建词汇列表
    def createVocabList(dataSet):
        # 定义词汇集
        vocabSet = set([])
        # 遍历文档
        for document in dataSet:
            # 将每个document合并到vocabSet，|用来联合两个集合
            vocabSet = vocabSet | set(document)
        # 返回词汇集
        return list(vocabSet)

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

# 把单词转换成向量
    def setOfWords2Vec(vocabList, inputSet):
        # 定义要返回的向量
        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

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

> 运行结果

# 准备数据：从文本中构建词向量运行结果:
    listOPosts,listClasses = loadDataSet()
    myVocabList = createVocabList(listOPosts)
    print(myVocabList)
    #['has', 'problem', 'dalmation', 'I', 'how', 'licks', 'ate', 'cute',
    # 'maybe', 'dog', 'love', 'garbage', 'please', 'help', 'flea', 'not',
    # 'so', 'is', 'food', 'park', 'to', 'quit', 'stupid', 'him', 'posting', '
    # stop', 'steak', 'mr', 'buying', 'my', 'take', 'worthless']

print(setOfWords2Vec(myVocabList,listOPosts[0]))
    #listOPosts[0]: <class 'list'>: ['my', 'dog', 'has', 'flea', 'problem', 'help', 'please']
    #[0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]

print(setOfWords2Vec(myVocabList,listOPosts[3]))
    #listOPosts[3]: <class 'list'>: ['stop', 'posting', 'stupid', 'worthless', 'garbage']
    #[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]

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

前面介绍了如何将一组单词转换为一组数字，接下来看看如何使用这些数字计算概率。 我们重写贝叶斯准则，将之前的x、 y 替换为 w  \\boldsymbol\{w\} w。粗体 w  \\boldsymbol\{w\} w表示这是一个向量，即它由多个数值组成。在这个例子中，数值个数与词汇表中的词个数相同。

p ( c i ∣ w ) = p ( w ∣ c i ) p ( c i ) p ( w )  p\\left(c\_\{i\} | \\boldsymbol\{w\}\\right)=\\frac\{p\\left(\\boldsymbol\{w\} | c\_\{i\}\\right) p\\left(c\_\{i\}\\right)\}\{p(\\boldsymbol\{w\})\} p(ci∣w)=p(w)p(w∣ci)p(ci)

独立特征简化为 p ( w 0 ∣ c i ) p ( w 1 ∣ c i ) p ( w 2 ∣ c i ) … p ( w N ∣ c i )  \\mathrm\{p\}\\left(\\mathrm\{w\}\_\{0\} | \\mathrm\{c\}\_\{\\mathrm\{i\}\}\\right) \\mathrm\{p\}\\left(\\mathrm\{w\}\_\{1\} | \\mathrm\{c\}\_\{\\mathrm\{i\}\}\\right) \\mathrm\{p\}\\left(\\mathrm\{w\}\_\{2\} | \\mathrm\{c\}\_\{\\mathrm\{i\}\}\\right) \\ldots \\mathrm\{p\}\\left(\\mathrm\{w\}\_\{\\mathrm\{N\}\} | \\mathrm\{c\}\_\{\\mathrm\{i\}\}\\right) p(w0∣ci)p(w1∣ci)p(w2∣ci)…p(wN∣ci)

> 函数的伪代码

计算每个类别中的文档数目
    对每篇训练文档：
    	对每个类别：
    		如果词条出现在文档中→ 增加该词条的计数值
    		增加所有词条的计数值
    	对每个类别：
    		对每个词条：
    			将该词条的数目除以总词条数目得到条件概率
    	返回每个类别的条件概率

该函数使用了`NumPy`的一些函数，故应确保将`from numpy import *`语句添加到`bayes.py`文件的最前面

> 朴素贝叶斯分类器训练函数

# 条件概率的计算
    def trainNB0(trainMatrix,trainCategory):
        # 计算文档的数目
        numTrainDocs = len(trainMatrix)
        # 计算单词的数目
        numWords = len(trainMatrix[0])
        # 计算类别的概率，abusive为1，not abusive为0
        pAbusive =sum(trainCategory) / float(numTrainDocs)
        # 初始化计数器，1行numWords列，p0是not abusive
        # p0Num =zeros(numWords)
        p0Num = ones(numWords)
        # 初始化计数器，p1是abusive
        p1Num = ones(numWords)
        # 初始化分母
        p0Denom = 2.0
        p1Denom = 2.0
        # 遍历文档
        for i in range(numTrainDocs):
            # 计算abusive对应的词汇的数目，trainMatrix为0-1值形成的向量
            if trainCategory[i] == 1:
                # p1Num存储的是每个词出现的次数
                p1Num += trainMatrix[i]
                # p1Denom存储的是词的总数目
                p1Denom += sum(trainMatrix[i])
            # 计算not abusive词汇的数目
            else:
                # 每个词在not abusive下出现的次数
                p0Num += trainMatrix[i]
                # not abusive下的总词数
                p0Denom += sum(trainMatrix[i])
        # 计算abusive下每个词出现的概率
        # p1Vect = p1Num / p1Denom
        p1Vect = log(p1Num / p1Denom)
        # 计算not abusive下每个词出现的概率
        # p0Vect = p0Num / p0Denom
        p0Vect = log(p0Num / p0Denom)
        # 返回词出现的概率和文档为abusive的概率，not abusive的概率为1-pAbusive
        return p0Vect,p1Vect,pAbusive

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

当 计 算 乘 积 p ( w 0 ∣ c i ) p ( w 1 ∣ c i ) p ( w 2 ∣ c i ) … p ( w N ∣ c i ) \\mathrm\{p\}\\left(\\mathrm\{w\}\_\{0\} | \\mathrm\{c\}\_\{\\mathrm\{i\}\}\\right) \\mathrm\{p\}\\left(\\mathrm\{w\}\_\{1\} | \\mathrm\{c\}\_\{\\mathrm\{i\}\}\\right) \\mathrm\{p\}\\left(\\mathrm\{w\}\_\{2\} | \\mathrm\{c\}\_\{\\mathrm\{i\}\}\\right) \\ldots \\mathrm\{p\}\\left(\\mathrm\{w\}\_\{\\mathrm\{N\}\} | \\mathrm\{c\}\_\{\\mathrm\{i\}\}\\right) p(w0∣ci)p(w1∣ci)p(w2∣ci)…p(wN∣ci)时，由于大部分因子都非常小，所以程序会下溢出或者  
得到不正确的答案。 一种解决办法是对乘积取自然对数。在代数中有 ln ⁡ ( a ⋆ b ) = ln ⁡ ( a ) + ln ⁡ ( b ) \\ln \\left(a^\{\\star\} b\\right)=\\ln (a)+\\ln (b) ln(a⋆b)=ln(a)\+ln(b)，于是通过求对数可以避免下溢出或者浮点数舍入导致的错误。同时，采用自然对数进行处理不会有任何损失。

> 运行结果

# 从预先加载值中调入数据
    listOPosts,listClasses = loadDataSet()
    #listOPosts: <class 'list'>: [['my', 'dog', 'has', 'flea', 'problem', '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']]
    #listClasses: <class 'list'>: [0, 1, 0, 1, 0, 1]
    # 构建了一个包含所有词的列表myVocabList
    myVocabList = createVocabList(listOPosts)
    #myVocabList: <class 'list'>: ['ate', 'stupid', 'flea', 'mr', 'dog', 'my', 'love', 'licks', 'him', 'stop', 'dalmation', 'quit', 'I', 'not', 'help', 'please', 'take', 'garbage', 'cute', 'problem', 'to', 'posting', 'food', 'so', 'is', 'how', 'maybe', 'buying', 'worthless', 'steak', 'has', 'park']
    trainMat = []
    # for循环使用词向量来填充trainMat列表
    for postinDoc in listOPosts:
        trainMat.append(setOfWords2Vec(myVocabList,postinDoc))
    #trainMat: <class 'list'>: [[0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0]]

p0v,p1v,pAb = trainNB0(trainMat,listClasses)
    #?进入trainNB0函数进行
    
    # 条件概率的计算
    def trainNB0(trainMatrix,trainCategory):
        numTrainDocs = len(trainMatrix) #numTrainDocs: 6
        numWords = len(trainMatrix[0]) #numWords: 32
        pAbusive =sum(trainCategory) / float(numTrainDocs) #pAbusive: 0.5
        p0Num = ones(numWords) #p0Num: [ 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
        p1Num = ones(numWords)# p1Num == p0Num
        p0Denom = 2.0 #p0Denom: 2
        p1Denom = 2.0 #p1Denom: 2
        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

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

> 朴素贝叶斯分类函数

#代码有4个输入：要分类的向量vec2Classify以及使用函数trainNB0()计算得到的三个概率。
    def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):
        # 计算abusive的概率
        p1 = sum(vec2Classify * p1Vec) + log(pClass1)
        # 计算not abusive的概率
        p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
        # 根据概率大小判断属于哪个类
        if p1 > p0:
            return 1
        else:
            return 0

第二个函数是一个便利函数（convenience function），该函数封装所有操作，以节省输入代码的时间。

# 测试
    def testingNB():
        # 加载数据集
        listOPosts,listClass = loadDataSet()
        # 创建词汇列表
        myVocabList = createVocabList(listOPosts)
        trainMat = []
        for postinDoc in listOPosts:
            trainMat.append(setOfWords2Vec(myVocabList,postinDoc))
        p0V,p1V,pAb = trainNB0(array(trainMat),array(listClass))
        # print p0V,p1V,pAb
        # print trainMat
        testEntry = ['love','my','dalmation']
        thisDoc = array(setOfWords2Vec(myVocabList,testEntry))#[0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0]
        print(testEntry, 'classified as:', classifyNB(thisDoc, p0V, p1V, pAb))#['love', 'my', 'dalmation'] classified as: 0
        testEntry = ['stupid', 'garbage']
        thisDoc = array(setOfWords2Vec(myVocabList, testEntry))#[0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
        print(testEntry, 'classified as:', classifyNB(thisDoc, p0V, p1V, pAb))#['stupid', 'garbage'] classified as: 1

> 运行结果

['love', 'my', 'dalmation'] classified as: 0
    ['stupid', 'garbage'] classified as: 1

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

目前为止，我们将每个词的出现与否作为一个特征，这可以被描述为词集模型（set-of-wordsmodel）。如果一个词在文档中出现不止一次，这可能意味着包含该词是否出现在文档中所不能表达的某种信息，这种方法被称为词袋模型（bag-of-words model）。在词袋中，每个单词可以出现多次，而在词集中，每个词只能出现一次。为适应词袋模型，需要对函数setOfWords2Vec()稍加修改，修改后的函数称为bagOfWords2Vec()。

# 把单词转换成向量,用词袋模型，计算词出现的次数
    def bagOfWords2VecMN(vocabList,inputSet):
        # 定义要返回的向量
        returnVec = [0] * len(vocabList)
        # 遍历输出集中的单词
        for word in inputSet:
            # 单词在词汇集中
            if word in vocabList:
                # 对应的词出现次数 加1
                returnVec[vocabList.index(word)] += 1
        # 返回向量
        return returnVec

[aHR0cHM6Ly93czEuc2luYWltZy5jbi9sYXJnZS8wMDZReW4yUWx5MWc1OWt1amQ4eGdqMzBuaTBpOHRmYS5qcGc]: /images/20211126/e38e6c418c0f46848e1c98b8e12b1f76.png