基于几率论的分类方法：朴素贝叶斯

基于几率论的分类方法：朴素贝叶斯

1. 概述

贝叶斯分类是一类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类。本章首先介绍贝叶斯分类算法的基础——贝叶斯定理。最后，咱们经过实例来讨论贝叶斯分类的中最简单的一种: 朴素贝叶斯分类。

2. 贝叶斯理论 & 条件几率

2.1 贝叶斯理论

咱们如今有一个数据集，它由两类数据组成，数据分布以下图所示：

咱们如今用 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

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

2.1.2 条件几率

若是你对 p(x,y|c1) 符号很熟悉，那么能够跳过本小节。

有一个装了 7 块石头的罐子，其中 3 块是白色的，4 块是黑色的。若是从罐子中随机取出一块石头，那么是白色石头的可能性是多少？因为取石头有 7 种可能，其中 3 种为白色，因此取出白色石头的几率为 3/7 。那么取到黑色石头的几率又是多少呢？很显然，是 4/7 。咱们使用 P(white) 来表示取到白色石头的几率，其几率值能够经过白色石头数目除以总的石头数目来获得。

若是这 7 块石头以下图所示，放在两个桶中，那么上述几率应该如何计算？

计算 P(white) 或者 P(black) ，若是事先咱们知道石头所在桶的信息是会改变结果的。这就是所谓的条件几率（conditional probablity）。假定计算的是从 B 桶取到白色石头的几率，这个几率能够记做 P(white|bucketB) ，咱们称之为“在已知石头出自 B 桶的条件下，取出白色石头的几率”。很容易获得，P(white|bucketA) 值为 2/4 ，P(white|bucketB) 的值为 1/3 。

条件几率的计算公式以下：

P(white|bucketB) = P(white and bucketB) / P(bucketB)

首先，咱们用 B 桶中白色石头的个数除以两个桶中总的石头数，获得 P(white and bucketB) = 1/7 .其次，因为 B 桶中有 3 块石头，而总石头数为 7 ，因而 P(bucketB) 就等于 3/7 。因而又 P(white|bucketB) = P(white and bucketB) / P(bucketB) = (1/7) / (3/7) = 1/3 。

另一种有效计算条件几率的方法称为贝叶斯准则。贝叶斯准则告诉咱们如何交换条件几率中的条件与结果，即若是已知 P(x|c)，要求 P(c|x)，那么可使用下面的计算方法：

使用条件几率来分类

上面咱们提到贝叶斯决策理论要求计算两个几率 p1(x, y) 和 p2(x, y):

若是 p1(x, y) > p2(x, y), 那么属于类别 1;
若是 p2(x, y) > p1(X, y), 那么属于类别 2.

这并非贝叶斯决策理论的全部内容。使用 p1() 和 p2() 只是为了尽量简化描述，而真正须要计算和比较的是 p(c1|x, y) 和 p(c2|x, y) .这些符号所表明的具体意义是: 给定某个由 x、y 表示的数据点，那么该数据点来自类别 c1 的几率是多少？数据点来自类别 c2 的几率又是多少？注意这些几率与几率 p(x, y|c1) 并不同，不过可使用贝叶斯准则来交换几率中条件与结果。具体地，应用贝叶斯准则获得:

使用上面这些定义，能够定义贝叶斯分类准则为:

若是 P(c1|x, y) > P(c2|x, y), 那么属于类别 c1;
若是 P(c2|x, y) > P(c1|x, y), 那么属于类别 c2.

在文档分类中，整个文档（如一封电子邮件）是实例，而电子邮件中的某些元素则构成特征。咱们能够观察文档中出现的词，并把每一个词做为一个特征，而每一个词的出现或者不出现做为该特征的值，这样获得的特征数目就会跟词汇表中的词的数目同样多。

咱们假设特征之间 相互独立 。所谓 独立(independence) 指的是统计意义上的独立，即一个特征或者单词出现的可能性与它和其余单词相邻没有关系，好比说，“咱们”中的“我”和“们”出现的几率与这两个字相邻没有任何关系。这个假设正是朴素贝叶斯分类器中 朴素(naive) 一词的含义。朴素贝叶斯分类器中的另外一个假设是，每一个特征同等重要。

Note: 朴素贝叶斯分类器一般有两种实现方式: 一种基于伯努利模型实现，一种基于多项式模型实现。这里采用前一种实现方式。该实现方式中并不考虑词在文档中出现的次数，只考虑出不出现，所以在这个意义上至关于假设词是等权重的。

2.2 朴素贝叶斯 场景

机器学习的一个重要应用就是文档的自动分类。

在文档分类中，整个文档（如一封电子邮件）是实例，而电子邮件中的某些元素则构成特征。咱们能够观察文档中出现的词，并把每一个词做为一个特征，而每一个词的出现或者不出现做为该特征的值，这样获得的特征数目就会跟词汇表中的词的数目同样多。

朴素贝叶斯是上面介绍的贝叶斯分类器的一个扩展，是用于文档分类的经常使用算法。下面咱们会进行一些朴素贝叶斯分类的实践项目。

2.3 朴素贝叶斯 原理

朴素贝叶斯 工做原理

提取全部文档中的词条并进行去重
获取文档的全部类别
计算每一个类别中的文档数目
对每篇训练文档:

对每一个类别:
    若是词条出如今文档中-->增长该词条的计数值（for循环或者矩阵相加）
    增长全部词条的计数值（此类别下词条总数）

对每一个类别:

对每一个词条:
    将该词条的数目除以总词条数目获得的条件几率（P(词条|类别)）

返回该文档属于每一个类别的条件几率（P(类别|文档的全部词条)）

2.4 朴素贝叶斯 开发流程

收集数据: 可使用任何方法。

准备数据: 须要数值型或者布尔型数据。

分析数据: 有大量特征时，绘制特征做用不大，此时使用直方图效果更好。

训练算法: 计算不一样的独立特征的条件几率。

测试算法: 计算错误率。

使用算法: 一个常见的朴素贝叶斯应用是文档分类。能够在任意的分类场景中使用朴素贝叶斯分类器，不必定非要是文本。

2.5 朴素贝叶斯 算法特色

优势: 在数据较少的状况下仍然有效，能够处理多类别问题。
缺点: 对于输入数据的准备方式较为敏感。
适用数据类型: 标称型数据。

2.6 朴素贝叶斯 项目案例

2.6.1 项目案例1

屏蔽社区留言板的侮辱性言论

2.6.1.1 项目概述

构建一个快速过滤器来屏蔽在线社区留言板上的侮辱性言论。若是某条留言使用了负面或者侮辱性的语言，那么就将该留言标识为内容不当。对此问题创建两个类别: 侮辱类和非侮辱类，使用 1 和 0 分别表示。

2.6.1.2 开发流程

收集数据: 可使用任何方法

准备数据: 从文本中构建词向量

分析数据: 检查词条确保解析的正确性

训练算法: 从词向量计算几率

测试算法: 根据现实状况修改分类器

使用算法: 对社区留言板言论进行分类

收集数据: 可使用任何方法

2.6.1.3 构造词表

def loadDataSet():
    """
    建立数据集
    :return: 单词列表postingList, 所属类别classVec
    """
    postingList = [['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'], #[0,0,1,1,1......]
                   ['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 is abusive, 0 not
    return postingList, classVec

2.6.1.4 准备数据: 从文本中构建词向量

def createVocabList(dataSet):
    """
    获取全部单词的集合
    :param dataSet: 数据集
    :return: 全部单词的集合(即不含重复元素的单词列表)
    """
    vocabSet = set([])  # create empty set
    for document in dataSet:
        # 操做符 | 用于求两个集合的并集
        vocabSet = vocabSet | set(document)  # union of the two sets
    return list(vocabSet)


def setOfWords2Vec(vocabList, inputSet):
    """
    遍历查看该单词是否出现，出现该单词则将该单词置1
    :param vocabList: 全部单词集合列表
    :param inputSet: 输入数据集
    :return: 匹配列表[0,1,0,1...]，其中 1与0 表示词汇表中的单词是否出如今输入的数据集中
    """
    # 建立一个和词汇表等长的向量，并将其元素都设置为0
    returnVec = [0] * len(vocabList)# [0,0......]
    # 遍历文档中的全部单词，若是出现了词汇表中的单词，则将输出的文档向量中的对应值设为1
    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

2.6.1.5 分析数据: 检查词条确保解析的正确性

检查函数执行状况，检查词表，不出现重复单词，须要的话，能够对其进行排序。

>>> listOPosts, listClasses = bayes.loadDataSet()
>>> myVocabList = bayes.createVocabList(listOPosts)
>>> myVocabList
['cute', 'love', 'help', 'garbage', 'quit', 'I', 'problems', 'is', 'park',
'stop', 'flea', 'dalmation', 'licks', 'food', 'not', 'him', 'buying', 'posting', 'has', 'worthless', 'ate', 'to', 'maybe', 'please', 'dog', 'how',
'stupid', 'so', 'take', 'mr', 'steak', 'my']

检查函数有效性。例如：myVocabList 中索引为 2 的元素是什么单词？应该是是 help 。该单词在第一篇文档中出现了，如今检查一下看看它是否出如今第四篇文档中。

>>> bayes.setOfWords2Vec(myVocabList, listOPosts[0])
[0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1]

>>> bayes.setOfWords2Vec(myVocabList, listOPosts[3])
[0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]

2.6.1.6 训练算法: 从词向量计算几率

如今已经知道了一个词是否出如今一篇文档中，也知道该文档所属的类别。接下来咱们重写贝叶斯准则，将以前的 x, y 替换为 w. 粗体的 w 表示这是一个向量，即它由多个值组成。在这个例子中，数值个数与词汇表中的词个数相同。

咱们使用上述公式，对每一个类计算该值，而后比较这两个几率值的大小。

首先能够经过类别 i (侮辱性留言或者非侮辱性留言)中的文档数除以总的文档数来计算几率 p(ci) 。接下来计算 p(w | ci) ，这里就要用到朴素贝叶斯假设。若是将 w 展开为一个个独立特征，那么就能够将上述几率写做 p(w0, w1, w2...wn | ci) 。这里假设全部词都互相独立，该假设也称做条件独立性假设（例如 A 和 B 两我的抛骰子，几率是互不影响的，也就是相互独立的，A 抛 2点的同时 B 抛 3 点的几率就是 1/6 * 1/6），它意味着可使用 p(w0 | ci)p(w1 | ci)p(w2 | ci)...p(wn | ci) 来计算上述几率，这样就极大地简化了计算的过程。

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

def _trainNB0(trainMatrix, trainCategory):
    """
    训练数据原版
    :param trainMatrix: 文件单词矩阵 [[1,0,1,1,1....],[],[]...]
    :param trainCategory: 文件对应的类别[0,1,1,0....]，列表长度等于单词矩阵数，其中的1表明对应的文件是侮辱性文件，0表明不是侮辱性矩阵
    :return:
    """
    # 文件数
    numTrainDocs = len(trainMatrix)
    # 单词数
    numWords = len(trainMatrix[0])
    # 侮辱性文件的出现几率，即trainCategory中全部的1的个数，
    # 表明的就是多少个侮辱性文件，与文件的总数相除就获得了侮辱性文件的出现几率
    pAbusive = sum(trainCategory) / float(numTrainDocs)
    # 构造单词出现次数列表
    p0Num = zeros(numWords) # [0,0,0,.....]
    p1Num = zeros(numWords) # [0,0,0,.....]

    # 整个数据集单词出现总数
    p0Denom = 0.0
    p1Denom = 0.0
    for i in range(numTrainDocs):
        # 是不是侮辱性文件
        if trainCategory[i] == 1:
            # 若是是侮辱性文件，对侮辱性文件的向量进行加和
            p1Num += trainMatrix[i] #[0,1,1,....] + [0,1,1,....]->[0,2,2,...]
            # 对向量中的全部元素进行求和，也就是计算全部侮辱性文件中出现的单词总数
            p1Denom += sum(trainMatrix[i])
        else:
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    # 类别1，即侮辱性文档的[P(F1|C1),P(F2|C1),P(F3|C1),P(F4|C1),P(F5|C1)....]列表
    # 即 在1类别下，每一个单词出现的几率
    p1Vect = p1Num / p1Denom# [1,2,3,5]/90->[1/90,...]
    # 类别0，即正常文档的[P(F1|C0),P(F2|C0),P(F3|C0),P(F4|C0),P(F5|C0)....]列表
    # 即 在0类别下，每一个单词出现的几率
    p0Vect = p0Num / p0Denom
    return p0Vect, p1Vect, pAbusive

2.6.1.8 测试算法: 根据现实状况修改分类器

http://www.cnblogs.com/apache...