机器学习之旅（三）：朴素贝叶斯

最新推荐文章于 2022-02-17 17:29:59 发布

樂仔的机器学习之旅

最新推荐文章于 2022-02-17 17:29:59 发布

阅读量400

点赞数

分类专栏：机器学习文章标签：机器学习朴素贝叶斯 Python

本文链接：https://blog.csdn.net/st8685203/article/details/79114239

版权

机器学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

机器学习之旅（二）：朴素贝叶斯

朴素贝叶斯工作原理

　　朴素贝叶斯法是基于贝叶斯定理与特征条件独立假设的分类方法。分类是将一个未知样本分到几个预先已知类的过程。数据分类问题的解决是一个两步过程：第一步,建立一个模型，描述预先的数据集或概念集。通过分析由属性描述的样本（或实例，对象等）来构造模型。假定每一个样本都有一个预先定义的类，由一个被称为类标签的属性确定。为建立模型而被分析的数据元组形成训练数据集，该步也称作有指导的学习。
　　在众多的分类模型中，应用最为广泛的两种分类模型是决策树模型(Decision Tree Model)和朴素贝叶斯模型（Naive Bayesian Model，NBC）。决策树模型通过构造树来解决分类问题。首先利用训练数据集来构造一棵决策树，一旦树建立起来，它就可为未知样本产生一个分类。在分类问题中使用决策树模型有很多的优点，决策树便于使用，而且高效；根据决策树可以很容易地构造出规则，而规则通常易于解释和理解；决策树可很好地扩展到大型数据库中，同时它的大小独立于数据库的大小；决策树模型的另外一大优点就是可以对有许多属性的数据集构造决策树。决策树模型也有一些缺点，比如处理缺失数据时的困难，过度拟合问题的出现，以及忽略数据集中属性之间的相关性等。
　　
　　朴素贝叶斯分类器基于一个简单的假定：给定目标值时属性之间相互条件独立。
　　通过以上定理和“朴素”的假定，我们知道：
　　P( Category | Document) = P ( Document | Category ) * P( Category) / P(Document)
　　

朴素贝叶斯的优缺点

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

决策树的一般流程

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

编写代码从文本中构建词向量

　　以在线社区的留言板为例。为了不影响社区的发展，我们要屏蔽侮辱性的言论，所以要构建一个快速的过滤器，如果某条留言使用了负面或者侮辱性的语言，那么就将该留言标识为内容不当。对此问题建立两个类别：侮辱类和非侮辱类，使用1和0分别表示。
　　我们将把文本看成单词向量或者词条向量，也就是说将句子转换为向量。考虑出现在所有文档中的所有单词，在决定将那些词纳入词汇表或者说所要的词汇集合，然后必须要将每一篇文档转换为词汇表上的向量。

# -*- coding:utf-8 -*-

"""
函数说明:创建实验样本

Parameters:
    无
Returns:
    postingList - 实验样本切分的词条
    classVec - 类别标签向量
Author:
    Jack Cui
"""


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


"""
函数说明:根据vocabList词汇表，将inputSet向量化，向量的每个元素为1或0

Parameters:
    vocabList - createVocabList返回的列表
    inputSet - 切分的词条列表
Returns:
    returnVec - 文档向量,词集模型
Author:
    Jack Cui
"""


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                                    # 返回文档向量


"""
函数说明:将切分的实验样本词条整理成不重复的词条列表，也就是词汇表

Parameters:
    dataSet - 整理的样本数据集
Returns:
    vocabSet - 返回不重复的词条列表，也就是词汇表
Author:
    Jack Cui
"""


def createVocabList(dataSet):
    vocabSet = set([])                          # 创建一个空的不重复列表
    for document in dataSet:
        vocabSet = vocabSet | set(document)     # 取并集
    return list(vocabSet)


if __name__ == '__main__':
    postingList, classVec = loadDataSet()
    print('postingList:\n', postingList)
    myVocabList = createVocabList(postingList)
    print('myVocabList:\n', myVocabList)
    trainMat = []
    for postinDoc in postingList:
        trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
    print('trainMat:\n', trainMat)

　　从运行结果可以看出，postingList是原始的词条列表。classVec是存放每个词条的所属类别，1代表侮辱类，0代表非侮辱类。myVocabList是词汇表。myVocabList是所有单词出现的集合，没有重复的元素。词汇表是用来干什么的？没错，它是用来将词条向量化的，一个单词在词汇表中出现过一次，那么就在相应位置记作1，如果没有出现就在相应位置记作0。trainMat是所有的词条向量组成的列表。它里面存放的是根据myVocabList向量化的词条向量。

这里写图片描述
　　

编写代码创建朴素贝叶斯分类器

　　接下来创建素贝叶斯分类器，代码编写如下

# -*- coding:utf-8 -*-

import numpy as np

"""
函数说明:创建实验样本

Parameters:
    无
Returns:
    postingList - 实验样本切分的词条
    classVec - 类别标签向量
Author:
    Jack Cui
"""


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


"""
函数说明:根据vocabList词汇表，将inputSet向量化，向量的每个元素为1或0

Parameters:
    vocabList - createVocabList返回的列表
    inputSet - 切分的词条列表
Returns:
    returnVec - 文档向量,词集模型
Author:
    Jack Cui
"""


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                                    # 返回文档向量


"""
函数说明:将切分的实验样本词条整理成不重复的词条列表，也就是词汇表

Parameters:
    dataSet - 整理的样本数据集
Returns:
    vocabSet - 返回不重复的词条列表，也就是词汇表
Author:
    Jack Cui
"""


def createVocabList(dataSet):
    vocabSet = set([])                          # 创建一个空的不重复列表
    for document in dataSet:
        vocabSet = vocabSet | set(document)     # 取并集
    return list(vocabSet)


"""
函数说明:朴素贝叶斯分类器训练函数

Parameters:
    trainMatrix - 训练文档矩阵，即setOfWords2Vec返回的returnVec构成的矩阵
    trainCategory - 训练类别标签向量，即loadDataSet返回的classVec
Returns:
    p0Vect - 侮辱类的条件概率数组
    p1Vect - 非侮辱类的条件概率数组
    pAbusive - 文档属于侮辱类的概率
Author:
    Jack Cui
"""


def trainNB0(trainMatrix, trainCategory):
    numTrainDocs = len(trainMatrix)                     # 计算训练的文档数目
    numWords = len(trainMatrix[0])                      # 计算每篇文档的词条数
    pAbusive = sum(trainCategory)/float(numTrainDocs)   # 文档属于侮辱类的概率
    p0Num = np.zeros(numWords)                          # 创建numpy.zeros数组，词条出现数初始化为0
    p1Num = np.zeros(numWords)
    p0Denom = 0.0                                       # 分母初始化为0
    p1Denom = 0.0
    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 = p1Num/p1Denom
    p0Vect = p0Num/p0Denom
    return p0Vect, p1Vect, pAbusive                     # 返回属于侮辱类的条件概率数组，属于非侮辱类的条件概率数组，文档属于侮辱类的概率


if __name__ == '__main__':
    postingList, classVec = loadDataSet()
    myVocabList = createVocabList(postingList)
    print('myVocabList:\n', myVocabList)
    trainMat = []
    for postinDoc in postingList:
        trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
    p0V, p1V, pAb = trainNB0(trainMat, classVec)
    print('p0V:\n', p0V)
    print('p1V:\n', p1V)
    print('classVec:\n', classVec)
    print('pAb:\n', pAb)

　　首先，我们发现文档属于侮辱类的概率pAb为0.5，该值是正确的。接下来看一看在给定文档类别调下词汇表中单词的出现概率，看看是否正确。p0V的第二个概率，就是stupid这个单词属于非侮辱类的概率为0。同理，p1V的第二个概率，就是stupid这个单词属于侮辱类的概率为0.15789474，也就是约等于15.79%的概率。这就意味着stupid是最能表征类别1(侮辱性文档类)的单词
　　
这里写图片描述
　　

编写代码创建分类器

　　已经训练好分类器，接下来，使用分类器进行分类。代码如下

# -*- coding:utf-8 -*-

import numpy as np
from functools import reduce

"""
函数说明:创建实验样本

Parameters:
    无
Returns:
    postingList - 实验样本切分的词条
    classVec - 类别标签向量
Author:
    Jack Cui
"""


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


"""
函数说明:根据vocabList词汇表，将inputSet向量化，向量的每个元素为1或0

Parameters:
    vocabList - createVocabList返回的列表
    inputSet - 切分的词条列表
Returns:
    returnVec - 文档向量,词集模型
Author:
    Jack Cui
"""


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                                    # 返回文档向量


"""
函数说明:将切分的实验样本词条整理成不重复的词条列表，也就是词汇表

Parameters:
    dataSet - 整理的样本数据集
Returns:
    vocabSet - 返回不重复的词条列表，也就是词汇表
Author:
    Jack Cui
"""


def createVocabList(dataSet):
    vocabSet = set([])                          # 创建一个空的不重复列表
    for document in dataSet:
        vocabSet = vocabSet | set(document)     # 取并集
    return list(vocabSet)


"""
函数说明:朴素贝叶斯分类器训练函数

Parameters:
    trainMatrix - 训练文档矩阵，即setOfWords2Vec返回的returnVec构成的矩阵
    trainCategory - 训练类别标签向量，即loadDataSet返回的classVec
Returns:
    p0Vect - 侮辱类的条件概率数组
    p1Vect - 非侮辱类的条件概率数组
    pAbusive - 文档属于侮辱类的概率
Author:
    Jack Cui
"""


def trainNB0(trainMatrix, trainCategory):
    numTrainDocs = len(trainMatrix)                     # 计算训练的文档数目
    numWords = len(trainMatrix[0])                      # 计算每篇文档的词条数
    pAbusive = sum(trainCategory)/float(numTrainDocs)   # 文档属于侮辱类的概率
    p0Num = np.zeros(numWords)                          # 创建numpy.zeros数组，词条出现数初始化为0
    p1Num = np.zeros(numWords)
    p0Denom = 0.0                                       # 分母初始化为0
    p1Denom = 0.0
    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 = p1Num/p1Denom
    p0Vect = p0Num/p0Denom
    return p0Vect, p1Vect, pAbusive                     # 返回属于侮辱类的条件概率数组，属于非侮辱类的条件概率数组，文档属于侮辱类的概率


"""
函数说明:朴素贝叶斯分类器分类函数

Parameters:
    vec2Classify - 待分类的词条数组
    p0Vec - 侮辱类的条件概率数组
    p1Vec -非侮辱类的条件概率数组
    pClass1 - 文档属于侮辱类的概率
Returns:
    0 - 属于非侮辱类
    1 - 属于侮辱类
Author:
    Jack Cui
"""


def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    p1 = reduce(lambda x, y: x*y, vec2Classify * p1Vec) * pClass1             # 对应元素相乘
    p0 = reduce(lambda x, y: x*y, vec2Classify * p0Vec) * (1.0 - pClass1)
    print('p0:', p0)
    print('p1:', p1)
    if p1 > p0:
        return 1
    else:
        return 0


"""
函数说明:测试朴素贝叶斯分类器

Parameters:
    无
Returns:
    无
Author:
    Jack Cui
"""


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


if __name__ == '__main__':
    testingNB()

　　我们测试了两个词条，在使用分类器前，也需要对词条向量化，然后使用classifyNB()函数，用朴素贝叶斯公式，计算词条向量属于侮辱类和非侮辱类的概率，但是从返回结果却发现这样写的算法无法进行分类，p0和p1的计算结果都是0，这里我们需要用到拉普拉斯平滑方法来解决问题。
　　
这里写图片描述
　　
　　利用贝叶斯分类器对文档进行分类时，要计算多个概率的乘积以获得文档属于某个类别的概率，即计算p(w0|1)p(w1|1)p(w2|1)。如果其中有一个概率值为0，那么最后的成绩也为0。显然，这样是不合理的，为了降低这种影响，可以将所有词的出现数初始化为1，并将分母初始化为2。这种做法就叫做拉普拉斯平滑(Laplace Smoothing)又被称为加1平滑，是比较常用的平滑方法，它就是为了解决0概率问题。
　　除此之外，另外一个遇到的问题就是下溢出，这是由于太多很小的数相乘造成的。学过数学的人都知道，两个小数相乘，越乘越小，这样就造成了下溢出。在程序中，在相应小数位置进行四舍五入，计算结果可能就变成0了。为了解决这个问题，对乘积结果取自然对数。通过求对数可以避免下溢出或者浮点数舍入导致的错误。同时，采用自然对数进行处理不会有任何损失。
　　因此我们对trainNB0(trainMatrix, trainCategory)函数和classifyNB(vec2Classify, p0Vec, p1Vec, pClass1)进行更改，修改代码如下

"""
函数说明:朴素贝叶斯分类器训练函数

Parameters:
    trainMatrix - 训练文档矩阵，即setOfWords2Vec返回的returnVec构成的矩阵
    trainCategory - 训练类别标签向量，即loadDataSet返回的classVec
Returns:
    p0Vect - 侮辱类的条件概率数组
    p1Vect - 非侮辱类的条件概率数组
    pAbusive - 文档属于侮辱类的概率
Author:
    Jack Cui
"""


def trainNB0(trainMatrix, trainCategory):
    numTrainDocs = len(trainMatrix)                     # 计算训练的文档数目
    numWords = len(trainMatrix[0])                      # 计算每篇文档的词条数
    pAbusive = sum(trainCategory)/float(numTrainDocs)   # 文档属于侮辱类的概率
    p0Num = np.ones(numWords)                          # 创建numpy.ones数组，词条出现数初始化为1,拉普拉斯平滑
    p1Num = np.ones(numWords)
    p0Denom = 2.0                                       # 分母初始化为2,拉普拉斯平滑
    p1Denom = 2.0
    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                     # 返回属于侮辱类的条件概率数组，属于非侮辱类的条件概率数组，文档属于侮辱类的概率


"""
函数说明:朴素贝叶斯分类器分类函数

Parameters:
    vec2Classify - 待分类的词条数组
    p0Vec - 侮辱类的条件概率数组
    p1Vec -非侮辱类的条件概率数组
    pClass1 - 文档属于侮辱类的概率
Returns:
    0 - 属于非侮辱类
    1 - 属于侮辱类
Author:
    Jack Cui
"""


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)
    print('p0:', p0)
    print('p1:', p1)
    if p1 > p0:
        return 1
    else:
        return 0

　　这样，我们的朴素贝叶斯分类器就改进完毕了。
　　
感谢代码原作者：Jack-Cui
原文链接：http://blog.csdn.net/c406495762/article/details/77341116

樂仔的机器学习之旅

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
机器学习之旅（三）：朴素贝叶斯

机器学习之旅（二）：朴素贝叶斯朴素贝叶斯工作原理　　朴素贝叶斯法是基于贝叶斯定理与特征条件独立假设的分类方法。分类是将一个未知样本分到几个预先已知类的过程。数据分类问题的解决是一个两步过程：第一步,建立一个模型，描述预先的数据集或概念集。通过分析由属性描述的样本（或实例，对象等）来构造模型。假定每一个样本都有一个预先定义的类，由一个被称为类标签的属性确定。为建立模型而被分析的数据元
复制链接

扫一扫