朴素贝叶斯

2019-03-03 本文已影响27人低吟浅唱1990

机器学习实战

朴素贝叶斯算法可以要求分类器给出一个最优的类别猜测结果，同时给出这个猜测的概率估计值。

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

优点在数据较少的情况下仍然有效，可以处理多类别问题
缺点对于输入数据的准备方式较为敏感

假设有一个数据集，由两类数据组成，现用p1(x,y)表示数据点(x,y)属于类别1的概率，p2(x,y)表示数据点(x,y)属于类别2的概率，那么对于一个新数据点(x,y)，则它的类别：

如果 p1(x,y) > p2(x,y),那么类别1；
如果 p1(x,y) < p2(x,y),那么类别2。

条件概率

假设现在有一个装了7块石头的罐子，其中3块是灰色的，4块是黑色的。如果从罐子中随机取出一块石头，那么灰色石头的可能性是多少？ p(gray) = 3/7。取出的石头黑色石头则是p(black) 4/7。
现在将这7块石头放进A桶中(2黑2灰)和B桶中(1灰2黑)，要计算p(gray)或者p(black)事先得知道石头所在桶的信息会不会改变结果？这就是条件概率。假定计算的是从B桶渠道的灰色石头的概率，这个概率可以记作P(gray|bucketB)，不难得到P(gray|bucketB) = 1/3，P(gray|bucketA) = 2/4。
解析由于B桶中灰色石头的个数除以两个桶中的总的石头数，得到P(gray and buckets) = 1/7。其次由于B桶中有3块石头，而总石头数为7，于是P(bucketB)就等于3/7。于是又P(gray|bucketB) = P(gray and buckets)/P(bucketB)。

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

使用条件概率来分类

$\ p({{c_i}\mid{x,y}}) \$ = $\frac{{p({x,y}\mid{c_i})}{p({c_i})}}{p({x,y})} \$
结合上节中提出的概率分类和贝叶斯准则内容得到贝叶斯分类准则：

如果 $\ P(c_1\mid{x,y}) > P(c_2\mid{x,y}) \$ 那么类别 $\ c_1\$ ；
如果 $\ P(c_1\mid{x,y}) < P(c_2\mid{x,y}) \$ 那么类别 $\ c_2\$ ；

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

我们对文档进行简单的分类：侮辱类和非侮辱类，分别使用1和0表示。

将句子转换为向量

'''
创建一些实验样本
返回的第一个变量是进行词条切分后的文档集合
第二个变量是该类别的标签
'''
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 is abusive, 0 not
    return postingList,classVec

'''
返回一个在所有文档中出现的不重复此的列表
'''
def createVocabList(dataSet):
    vocabSet = set([])
    for document in dataSet:
        vocabSet = vocabSet | set(document)  #两个合集的并集
    arr = list(vocabSet)
    arr.sort()
    return arr

'''
该函数输入参数为词汇表及某个文档，输出的文档向量，向量的每一个元素为1或0，分别表示词汇表中的单词
在输入文档中是否出现
'''
def setOfWord2Vec(vocabList,inputSet):
    returnVec = [0]*len(vocabList)
    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

if __name__ == '__main__':
    listOposts, listClass = loadDataSet()
    myVocabList = createVocabList(listOposts)
    print(len(myVocabList))
    trainMat = []
    for postinDoc in listOposts:
        trainMat.append(setOfWord2Vec(myVocabList,postinDoc))
    print(trainMat)

>>>[[0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0],
 [1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1], 
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0], 
[0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1]]

从词向量到计算概率

现在我们知道一个词是否出现在文档中，也知道该文档所属的类别。将之前贝叶斯准则中(x,y)替换为w。表示一个向量
$\ p({{c_i}\mid{w}}) \$ = $\frac{{p({w}\mid{c_i})}{p({c_i})}}{p({w})} \$
我们将使用上述公司，对每个类计算该值，然后比较这两个概率值得大小。首先可以通过类别i中文档树除以总的文档数来计算概率 $\ p(c_i) \$ ，接着计算 $\ p({w}\mid{c_i}) \$ 。如果将 $\ w \$ 展开为一个个独立特征，那么就可以将上述概率写作 $\ p({{w_0,w_1,w_2..w_n}\mid{c_i}}) \$ 。那么就可以用 $\ p({w_0}\mid{c_i}) * p({w_1}\mid{c_i}) * p({w_2}\mid{c_i})...p({w_n}\mid{c_i})\$ 来计算上述概率。

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.0;p1Denom = 0.0;
    #遍历训练集文档，一旦某个词(侮辱性和正常词)出现，则相应的向量相加 总词数也相加
    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 = p1Num/p1Denom
    p0Vect = p0Num/p0Denom
    return p0Vect,p1Vect,pAbusive

p0V,p1V,pAb = trainNB0(trainMat,listClass)

根据现实情况修改分类器

利用贝叶斯分类器对文档进行分类时，要计算多个概率的乘积以获得文档属于某个类别的概率。如果其中一个概率值是0，那么最后的乘积也是0.为降低这种影响，可以将所有词的出现树初始化为1，并将分母初始化为2.

    p0Num = ones(numWords);p1Num = ones(numWords)  #初始化概率
    p0Denom = 2.0;p1Denom = 2.0;

当计算 $\ p({w_0}\mid{c_i}) * p({w_1}\mid{c_i}) * p({w_2}\mid{c_i})...p({w_n}\mid{c_i})\$ 乘积时，由于大部分因子都非常小，程序会下溢出或者得不到正确的答案。解决办法是对乘积去自然对数。代数中有ln(a*b) = ln(a)+ln(b)，通过求对数可以避免下溢出或者浮点数舍入导致的错误。同时，采用自然对数进行处理不会有任何损失。

    p1Vect = log(p1Num/p1Denom)
    p0Vect = log(p0Num/p0Denom)

def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):

    p1 = sum(vec2Classify*p1Vec) + log(pClass1)
    p0 = sum(vec2Classify*p1Vec) + log(1- pClass1)
    if p1 > p0:
        return 1
    else:
        return 0

if __name__ == '__main__':
    listOposts, listClass = loadDataSet()
    myVocabList = createVocabList(listOposts)
    print(len(myVocabList))
    trainMat = []
    for postinDoc in listOposts:
        trainMat.append(setOfWord2Vec(myVocabList,postinDoc))
    p0V,p1V,pAb = trainNB0(trainMat,listClass)
    testEntry = ['love','my','dalmation']
    thisDoc = array(setOfWord2Vec(myVocabList,testEntry))
    print("classify is: ",classifyNB(thisDoc,p0V,p1V,pAb))
>>> 0

示例和sk写法待续...