朴素贝叶斯

朴素贝叶斯简介

朴素贝叶斯是贝叶斯决策理论的一部分，在讲朴素贝叶斯之前，先快速了解下贝叶斯决策理论。

大街上有着形形色色的人，有的人西装革履，有的人衣衫褴褛，当我们看到一个穿着西装，开着豪车的人，我们一般会把他归类到有钱人这一分类中，因为在我们的潜意识里，穿着西装开着豪车的人是有钱人的概率，要大过是穷人的概率。也就是说，我们会选择高概率对应的类别来分类，这就是贝叶斯决策理论的核心思想，即选择具有最高概率的决策。

贝叶斯定理

在高中或者大学我们都学过，已知事件B发生的概率下，求事件A发生的概率，我们通常用P(A|B)来表示，其求解公式为：

而贝叶斯定理则为我们通过P(A|B)获得P(B|A)指明了道路，贝叶斯定理：

 有了这些基础，我们现在可以了解一下朴素贝叶斯，朴素贝叶斯是一种简单的分类算法，它的基本思想是：对于给出待分类项，求解此项出现的条件下在各个类别出现的概率，哪个概率最大，就属于哪个类别。

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

 由统计学得知，如果每个特征需要N个样本，那么对于10个特征则需要N¹⁰个样本，而1000个特征则需要N¹⁰⁰⁰个样本，可以看到，所需要的样本数会随着特征数目的增大而迅速增大。如果特征之间相互独立，那么样本数就可以从N¹⁰⁰⁰减少到1000*N了。所谓独立，指的是统计意义上的独立，即一个特征出现的可能性与它相邻的特征没有关系。举个例子，如果一个人的健康状况由体重和身高决定，体重和身高分别是两个特征，而体重的样本假设有[45kg，50kg],身高的样本假设有[160cm，175cm，180cm]，我们需要判断一个人是否健康，需要2*3个样本才能包含所有的情况，即之前说的1000个特征则需要N¹⁰⁰⁰个样本，如果现在判断一个人是否健康只要知道他的体重或者身高即可，就代表体重和身高是两个独立的特征，仅需2+3个特征，就能知道知道一个人是否健康。

假设一个论坛中有很多留言，为了屏蔽某些侮辱性的留言，需要基于计算条件概率来构建分类器。

代码1-1为词表到向量的转换函数

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]  # 0代表正常言论，1代表侮辱性言论
    return postingList, classVec


def createVocabList(dataSet):
    vocabSet = set([])
    for document in dataSet:
        vocabSet |= set(document)  # 创建两个集合的并集
    return list(vocabSet)


def setOfWords2Vec(vocabList, inputSet):
    returnVec = [0] * len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] = 1
        else:
            "the word: %s is not in my Vocabulary!" % word
    return returnVec

　　　　

代码1-1中，第一个函数loadDataSet()创建了一些实验样本，第一个变量是文档集合，第二个变量是类标签集合，这里有两类，侮辱性和非侮辱性的。第二个函数createVocabList()会返回一个列表，列表中包含所有言论的单词且不重复。获得词汇表后，便可以使用第三个函数setOfWords2Vec()，该函数的输入参数为词汇表以及某条评论，输出的是文档向量，向量的每个元素为1或0，分别表示词汇表中的单词在输入文档中是否出现。

调用代码1-1的运行效果：

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

　　

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

前面介绍了如何将一组单词转换为一组数字，接下来便要使用这些数字计算概率。前面提到了贝叶斯准则，这里我们要重写贝叶斯准则：

基于上述的公式，对每个类计算该值，然后比较这两个概率值的大小。首先，可以通过类别i（侮辱性留言和非侮辱性留言）中文档数除以总的文档数来计算概率P(c_i)。接下来计算P(w|c_i)，这里用到朴素贝叶斯假设。如果将w展开为一个个独立特征，那么就可以将上述概率写作P(w₀,w₁,w₂……，w_n|c_i)，它意味着可以使用P(w₀|c_i)P(w₁|c_i)P(w₂|c_i)P(w_n|c_i)来计算上述的概率。

代码1-2朴素贝叶斯分类器训练函数

from numpy import *


def trainNB0(trainMatrix, trainCategory):
    numTrainDocs = len(trainMatrix)
    numWords = len(trainMatrix[0])
    pAbusive = sum(trainCategory) / float(numTrainDocs)
    # 初始化概率
    p0Num = zeros(numWords)
    p1Num = zeros(numWords)
    p0Denom = 0
    p1Denom = 0
    for i in range(numTrainDocs):
        # 向量相加
        if trainCategory[i] == 0:
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
        else:
            p1Num += trainMatrix[i]
            p1Denom += sum(trainMatrix[i])
    # 将每个词条的数目除以总词条数目得到条件概率
    p0Vect = p0Num / p0Denom
    p1Vect = p1Num / p1Denom
    return p0Vect, p1Vect, pAbusive

　　

调用代码1-2的运行结果：

>>> listOposts, listClasses = loadDataSet()
>>> myVocabList = createVocabList(listOposts)
>>> trainMat = []
>>> for postinDoc in listOposts:
...     trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
...
>>> p0V, p1V, pAb = trainNB0(trainMat, listClasses)
>>> p0V
array([ 0.04166667,  0.04166667,  0.04166667,  0.        ,  0.04166667,
        0.04166667,  0.04166667,  0.        ,  0.04166667,  0.04166667,
        0.04166667,  0.04166667,  0.        ,  0.        ,  0.08333333,
        0.        ,  0.        ,  0.        ,  0.        ,  0.04166667,
        0.04166667,  0.        ,  0.04166667,  0.04166667,  0.04166667,
        0.        ,  0.04166667,  0.        ,  0.04166667,  0.04166667,
        0.04166667,  0.125     ])
>>> p1V
array([ 0.        ,  0.        ,  0.        ,  0.05263158,  0.        ,
        0.        ,  0.        ,  0.05263158,  0.05263158,  0.        ,
        0.        ,  0.        ,  0.05263158,  0.05263158,  0.05263158,
        0.05263158,  0.05263158,  0.05263158,  0.10526316,  0.        ,
        0.        ,  0.05263158,  0.        ,  0.10526316,  0.05263158,
        0.15789474,  0.        ,  0.05263158,  0.        ,  0.        ,
        0.        ,  0.        ])
>>> pAb
0.5

　　

代码1-2还存在一些缺陷，利用贝叶斯分类器对文档进行粉了时，要计算多个概率的乘积以获得文档属于某个类别的概率。如果其中一个概率值为0，那么最后的乘积也为0，为了降低这种影响，可以将所有词的出现数初始化为1，并将分母初始化为2。同时还存在另一个问题是溢出，由于很多很小的数相乘，最后四舍五入会得到0。一种解决办法是对乘积取自然对数。在代数中有ln(a*b)=ln(a)+ln(b)，于是通过求对数可以避免溢出或浮点数四舍五入导致的错误。同时，采用自然对象进行处理不会有任何损失。图1-3给出了函数f(x)和ln(f(x))的曲线，检查者两条曲线，就会发现它们在相当区域内同时增加或同时减少，并在相同点取到极值。虽然它们取值不同，但并不影响最终结果。

　　

经过上述修改，代码1-2应改为如代码1-4

代码1-4

from numpy import *


def trainNB0(trainMatrix, trainCategory):
    numTrainDocs = len(trainMatrix)
    numWords = len(trainMatrix[0])
    pAbusive = sum(trainCategory) / float(numTrainDocs)
    # 初始化概率
    p0Num = ones(numWords)
    p1Num = ones(numWords)
    p0Denom = 2
    p1Denom = 2
    for i in range(numTrainDocs):
        # 向量相加
        if trainCategory[i] == 0:
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
        else:
            p1Num += trainMatrix[i]
            p1Denom += sum(trainMatrix[i])
    # 将每个词条的数目除以总词条数目得到条件概率
    p0Vect = log(p0Num / p0Denom)
    p1Vect = log(p1Num / p1Denom)
    return p0Vect, p1Vect, pAbusive

　　

代码1-5朴素贝叶斯分类函数

def classifyNB(vec2Classify, p0Vec, p1Vec, p1Class):
    p0 = sum(vec2Classify * p0Vec) + log(1.0 - p1Class)
    p1 = sum(vec2Classify * p1Vec) + log(p1Class)
    if p1 > p0:
        return 1
    else:
        return 0


def testingNB():
    listOposts, listClasses = loadDataSet()
    myVocabList = createVocabList(listOposts)
    trainMat = []
    for postinDoc in listOposts:
        trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
    p0V, p1V, pAb = trainNB0(trainMat, listClasses)
    testEntry = ['love', 'my', 'dalmation']
    thisDoc = setOfWords2Vec(myVocabList, testEntry)
    print testEntry, ' classified as:', classifyNB(thisDoc, p0V, p1V, pAb)
    testEntry = ['stupid','garbage']
    thisDoc = setOfWords2Vec(myVocabList, testEntry)
    print testEntry, ' classified as:', classifyNB(thisDoc, p0V, p1V, pAb)

　　

调用代码1-5运行结果：

>>> testingNB()
['love', 'my', 'dalmation']  classified as: 0
['stupid', 'garbage']  classified as: 1

　　

代码1-9为本章代码整合

# coding:utf-8
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]  # 0代表正常言论，1代表侮辱性言论
    return postingList, classVec


def createVocabList(dataSet):
    vocabSet = set([])
    for document in dataSet:
        vocabSet |= set(document)  # 创建两个集合的并集
    return list(vocabSet)


def setOfWords2Vec(vocabList, inputSet):
    returnVec = [0] * len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] = 1
        else:
            "the word: %s is not in my Vocabulary!" % word
    return returnVec


from numpy import *


def trainNB0(trainMatrix, trainCategory):
    numTrainDocs = len(trainMatrix)
    numWords = len(trainMatrix[0])
    pAbusive = sum(trainCategory) / float(numTrainDocs)
    # 初始化概率
    p0Num = ones(numWords)
    p1Num = ones(numWords)
    p0Denom = 2
    p1Denom = 2
    for i in range(numTrainDocs):
        # 向量相加
        if trainCategory[i] == 0:
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
        else:
            p1Num += trainMatrix[i]
            p1Denom += sum(trainMatrix[i])
    # 将每个词条的数目除以总词条数目得到条件概率
    p0Vect = log(p0Num / p0Denom)
    p1Vect = log(p1Num / p1Denom)
    return p0Vect, p1Vect, pAbusive


def classifyNB(vec2Classify, p0Vec, p1Vec, p1Class):
    p0 = sum(vec2Classify * p0Vec) + log(1.0 - p1Class)
    p1 = sum(vec2Classify * p1Vec) + log(p1Class)
    if p1 > p0:
        return 1
    else:
        return 0


def testingNB():
    listOposts, listClasses = loadDataSet()
    myVocabList = createVocabList(listOposts)
    trainMat = []
    for postinDoc in listOposts:
        trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
    p0V, p1V, pAb = trainNB0(trainMat, listClasses)
    testEntry = ['love', 'my', 'dalmation']
    thisDoc = setOfWords2Vec(myVocabList, testEntry)
    print testEntry, ' classified as:', classifyNB(thisDoc, p0V, p1V, pAb)
    testEntry = ['stupid', 'garbage']
    thisDoc = setOfWords2Vec(myVocabList, testEntry)
    print testEntry, ' classified as:', classifyNB(thisDoc, p0V, p1V, pAb)