机器学习笔记(5)-贝叶斯模型

朴素贝叶斯决策理论

朴素贝叶斯法是基于贝叶斯定理与特征条件独立假设的分类方法。简单来说，朴素贝叶斯分类器假设样本每个特征与其他特征都不相关。朴素贝叶斯分类器的一个优势在于只需要根据少量的训练数据估计出必要的参数（离散型变量是先验概率和类条件概率，连续型变量是变量的均值和方差）。
用 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(x|c)，要求 P(c|x)，那么可以使用下面的计算方法：

真正需要计算和比较的是 p(c1|x, y) 和 p(c2|x, y) .这些符号所代表的具体意义是: 给定某个由 x、y 表示的数据点，那么该数据点来自类别 c1 的概率是多少？数据点来自类别 c2 的概率又是多少？

模型构建与实例

1.贝叶斯分类模型
X表示属性集，Y表示类变量，P(Y)为先验概率，P(X|Y)为类条件概率，P(X)为证据，P(Y|X)为后验概率。

(1)贝叶斯分类模型就是用先验概率P(Y)、类条件概率P(X|Y)和证据P(X)来表示后验概率。在比较Y的后验概率时，分母中的证据P(X)总是常数，因此可以忽略不计。
(2)先验概率P(Y)可以通过计算训练集中属于每个类的训练记录所占的比例很容易估计。
(3)对类条件概率P(X|Y)的估计，不同的实现决定不同的贝叶斯分类方法，常见的有朴素贝叶斯分类法和贝叶斯信念网络。
2.朴素贝叶斯分类模型


实例

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

词向量构建

def loadDataSet():
    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', 'gar e'],
                   ['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

def createVocabList(dataSet):
    '''
    :param dataSet: 数据集
    :return: 所有单词的集合(即不含重复元素的单词列表)
    '''
    vocabSet = set([])  # create empty set
    for document in dataSet:

        vocabSet = vocabSet | set(document)  # 操作符 | 用于求两个集合的并集
    return list(vocabSet)

def setOfWords2Vec(vocabList, inputSet):
    """遍历查看该单词是否出现，出现该单词则将该单词置1
    :param vocabList: 所有单词集合列表
    :param inputSet: 输入数据集
    :return: 匹配列表[0,1,0,1...]，其中 1与0 表示词汇表中的单词是否出现在输入的数据集中
    """
    returnVec = [0] * len(vocabList)# [0,0......]创建一个和词汇表等长的向量，并将其元素都设置为0
    for word in inputSet:      # 遍历文档中的所有单词，如果出现了词汇表中的单词，则将输出的文档向量中的对应值设为1
        if word in vocabList:
            returnVec[vocabList.index(word)] = 1
        else:
            print "the word: %s is not in my Vocabulary!" % word
    return returnVec
>>> 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]

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

p(ci)：通过类别 i (侮辱性留言或者非侮辱性留言)中的文档数除以总的文档数来计算概率。
p(w | ci)：将 w 展开为一个个独立特征，那么就可以将上述概率写作 p(w0, w1, w2…wn | ci) 。这里假设所有词都互相独立，该假设也称作条件独立性假设，意味着可以使用 p(w0 | ci)p(w1 | ci)p(w2 | ci)…p(wn | ci) 来计算上述概率

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])   # 单词数
    pAbusive = sum(trainCategory) / float(numTrainDocs)  # 侮辱性文件的出现概率，即trainCategory中所有的1的个数，与文件的总数相除就得到了侮辱性文件的出现概率
    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,...]
            p1Denom += sum(trainMatrix[i])
        else:
            p0Num += trainMatrix[i]  # 如果不是侮辱性文件，则计算非侮辱性文件中出现的侮辱性单词的个数
            p0Denom += sum(trainMatrix[i])
    p1Vect = p1Num / p1Denom  # 类别1，即侮辱性文档的[P(F1|C1),P(F2|C1),P(F3|C1),P(F4|C1),P(F5|C1)....]列表,即在1类别下，每个单词出现次数的占比;[1,2,3,5]/90->[1/90,...]
    p0Vect = p0Num / p0Denom   # 类别0，即正常文档的[P(F1|C0),P(F2|C0),P(F3|C0),P(F4|C0),P(F5|C0)....]列表,即在0类别下，每个单词出现次数的占比
    return p0Vect, p1Vect, pAbusive
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    p1 = sum(vec2Classify * p1Vec) + log(pClass1)
    p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
    if p1 > p0:
        return 1
    else:
        return 0