[机器学习常用算法]--朴素贝叶斯

朴素贝叶斯

核心思想

选择高概率对应的类别
假设：所有的特征之间是统计独立的。
即：

贝叶斯公式

P（A）称为“先验概率”（Prior probability），即在B事件发生之前，我们对A事件概率的一个判断。
P（A|B）称为“后验概率”（Posterior probability），即在B事件发生之后，我们对A事件概率的重新评估。
P（BIA）/P（B）称为“可能性函数”（Likely hood），这是一个调整因子，使得预估概率更接近真实概率。

所以条件概率可以理解为：后验概率=先验概率*调整因子

• 如果“可能性函数”>1，意味着“先验概率“被增强，事件A的发生的可能性变大；
• 如果”可能性函数“=1，意味着B事件无助于判断事件A的可能性；
• 如果”可能性函数“<1，意味着“先验概率“被削弱，事件A的可能性变小。

推理过程

同理

因此

化简得到：

python实现

from numpy import *

# 创建数据集
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']]
    # 分类标签
    # 1 is abusive(侮辱性词汇), 0 not（非侮辱性词汇）
    # 下面的六个数字对应着上面postingList矩阵中的六行，每行对应着一个标签
    label = [0, 1, 0, 1, 0, 1]
    return postingList, label

# 生成词汇表（无重复的词条）
def createVocabList(dataSet):
    # 不重复的词条
    vocabSet = set([])  # create empty set
    for document in dataSet:
        # 取集合vocabSet 和集合document的并集
        vocabSet = vocabSet | set(document)  # union of the two sets
    # list(vocabSet) 即：不重复词条的列表
    return list(vocabSet)

# vocabList词汇表
# inputSet输入文档
# 输出为文档向量
# def setOfWords2Vec(vocabList, inputSet):
#     # a = [0] * 3
#     # -->a=[0, 0, 0]
#     # 创建一个与词汇表长度相等的0向量
#     returnVec = [0] * len(vocabList)
#     # 遍历输入词条的每一个单词，若此单词存在于vocabList中，则把returnVec相应位置的零向量置为1
#     # 例
#     # vocabList = ['my', 'dog', 'has', 'flea', 'problems', 'help', 'please']
#     # returnVec = [0, 0, 0，0, 0, 0，0]
#     # inputSet = ['cat', 'dog', 'help']
#     # 经过此函数处理之后应该输出
#     # the word: ‘cat’ is not in my Vocabulary!
#     # returnVec = [0, 1, 0，0, 0, 1，0]
#     # 因为cat不在vocabList中，'dog', 'help'在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


# 功能与setOfWords2Vec类似
# 区别
# setOfWords2Vec中每个词只能出现一次
# bagOfWords2VecMN每个词可以出现多次
def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
    return returnVec

# trainMatrix   输入文档矩阵
# trainCategory 文档类别构成的向量，由0，1构成，
def trainNB0(trainMatrix, trainCategory):
    # 训练的文件数目
    numTrainDocs = len(trainMatrix) #每行代表一篇文档
    # 无重复词汇表中单词的数量
    numWords = len(trainMatrix[0])
    # 文档属于侮辱性文档的概率
    pAbusive = sum(trainCategory) / float(numTrainDocs)
    # 词条出现数初始化为1
    p0Num = ones(numWords)
    p1Num = ones(numWords)  # change to ones()
    # 分母初始化为2
    p0Denom = 2.0
    p1Denom = 2.0  # change to 2.0
    # 遍历所有文档，如果为1（侮辱性文档）
    # 则p1Num+1
    for i in range(numTrainDocs):
        if trainCategory[i] == 1:
            # trainMatrix即为文档向量，
            # 即：数据集中的某一行里面的词汇在“无重复词汇表”中对应的词汇位置的向量元素置为1，其他元素为0
            # trainMatrix[i]为向量文档的第i行
            p1Num += trainMatrix[i]
            p1Denom += sum(trainMatrix[i])
        else:
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    # p1Num向量代表了，对应位置的单词在侮辱性文章中出现的次数
    # p1Denom侮辱性文章中的单词总数
    p1Vect = log(p1Num / p1Denom)  # change to log()
    p0Vect = log(p0Num / p0Denom)  # change to log()
    return p0Vect, p1Vect, pAbusive

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

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

朴素贝叶斯改进之拉普拉斯平滑

由于贝叶斯公式存在下列项

因此，当其中的某一项为0时，则整体为0。

拉普拉斯平滑原理如下：

假设在文本分类中，有3个类，C1，C2，C3，在指定的训练样本中，某个词语K1，在各个类中观测计数分别为0，990，10，K1的概率为0，0.99，0.01，对这三个量使用拉普拉斯平滑的计算方法如下：

1/1003=0.001，991/1003=0.922，11/1003=0.011

在实际的使用中也经常使用加lambda(1>=lambda>=0)来代替简单的加1。如果对N个计数都加上lambda,这时分母也要记得加上N*lambda。