基于概率论的分类方法_贝叶斯理论

2019-08-03 本文已影响0人 Yonginggg

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

朴素贝叶斯
优点：在数据较少的情况下仍然有效，可以处理多类别问题。
缺点：对于输入数据的准备方式较为敏感。
适用数据类型：标称型数据。

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

image

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

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

条件概率

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

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

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

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

使用条件概率来分类

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

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

应用贝叶斯准则得到

$p\left(c_{i} | x, y\right)=\frac{p\left(x, y | c_{i}\right) p\left(c_{i}\right)}{p(x, y)}$

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

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

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

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

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

如果特征之间相互独立，那么样本数就可以从 $N^{1000}$ 减少到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 替换为 $\boldsymbol{w}$ 。粗体 $\boldsymbol{w}$ 表示这是一个向量，即它由多个数值组成。在这个例子中，数值个数与词汇表中的词个数相同。

$p\left(c_{i} | \boldsymbol{w}\right)=\frac{p\left(\boldsymbol{w} | c_{i}\right) p\left(c_{i}\right)}{p(\boldsymbol{w})}$

独立特征简化为 $\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)$

函数的伪代码

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

该函数使用了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

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

当计算乘积 $\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)$ 时，由于大部分因子都非常小，所以程序会下溢出或者
得到不正确的答案。一种解决办法是对乘积取自然对数。在代数中有 $\ln \left(a^{\star} b\right)=\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

基于概率论的分类方法_贝叶斯理论

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

条件概率

使用条件概率来分类

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

使用 Python 进行文本分类

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

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

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

准备数据：文档词袋模型

猜你喜欢

热点阅读