机器学习朴素贝叶斯学习笔记

基本概念

朴素贝叶斯是分类算法。

数据类型：标称型。

工作原理

如果p1(x, y) > p2(x, y)，类别为1
如果p2(x, y) > p1(x, y)，类别为2
也就是说，我们会选择高概率对应的类别。这就是贝叶斯决策理论的核心思想。

条件概率：

image.png

如果P(c1|x, y) > P(c2|x, y)，则类别为c1
如果P(c1|x, y) < P(c2|x, y)，则类别为c2

样例

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']]
    classVec = [0,1,0,1,0,1]    #1 is abusive, 0 not
    return postingList,classVec

找出侮辱性评论，并且把它屏蔽。

数据的转换

# 去重得到了所有词的集合。
def createVocabList(dataSet):
    vocabSet = set([]) 
    for document in dataSet:
        # 通过set去重
        vocabSet = vocabSet | set(document) 
    return list(vocabSet)

# 第一个参数为所有词的集合，第二个数为当前数据集。如果当前数据集的词在所有词的集合中出现则标记为1，否则默认是0
def setOfWords2Vec(vocabList, inputSet):
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            # 把词转换为向量，向量的每一元素为0或1
            returnVec[vocabList.index(word)] = 1
        else: print "the word: %s is not in my Vocabulary!" % word
    return returnVec

listOPosts,listClasses = loadDataSet()
myVocabList = createVocabList(listOPosts)
print 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']
print 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]

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

根据样例，用文字描述算法

image.png

• W是单词，Ci是类别
• P(W|Ci) => 在类别Ci的情况下单词W出现的概率
• P(Ci) => 这个类别在所有类别当中出现的概率
• P(W) => 这个词在所有词中出现的概率
• P(Ci|W) => 在单词W的情况下类别Ci出现的概率
• 已知P(W|Ci)（通过已知数据集算出）
• 求P(Ci|W)＝(P(W|Ci)*P(Ci))/P(W)

首先通过类别i（侮辱性留言或非侮辱性留言）中文档数除以总的文档数来计算概率P(Ci)。
这里要用到朴素贝叶斯假设，如果将w展开为一个个独立特征，那么就可以将上述概率写作P(W0,W1,W2...Wn|ci)。这里假设所有词都相互独立，该假设也称作条件独立性假设，意味这可以用
P(W0|ci)P(W1|ci)P(W2|ci)....P(Wn|ci)来计算上述概率，极大地简化了计算的过程。

伪代码：

• 计算每个类别中的文档数目
• 对每篇训练文档：
  • 对每个类别：
    • 如果词条出现文档中->增加该词条的计数值
    • 增加所有词条的计数值
  • 对每个类别：
    • 对每个词条：
      • 将该词条的数目除以总词条数目得到条件概率
  • 返回每个类别的条件概率

def trainNB0(trainMatrix,trainCategory):
    # 多少行数据 6
    numTrainDocs = len(trainMatrix)
    # 总共有多少个不重复的词组 32
    numWords = len(trainMatrix[0])
    # pAbusive侮辱性语言在所有词中的条件概率
    pAbusive = sum(trainCategory)/float(numTrainDocs)

    #避免乘积为0的初始化。如果其中一个概率的值为0，那么最后的乘积也为0
    p0Num = ones(numWords); p1Num = ones(numWords)
    p0Denom = 2.0; p1Denom = 2.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])
    # 相当于 P(W|C1) P(W|C2)每一个词出现的频率。侮辱性和非侮辱性。

    # 用log避免小数相乘的下溢出最后得到0，因为log的函数ln(f(x))曲线和f(x)类似
    p1Vect = log(p1Num/p1Denom)          #change to log()
    p0Vect = log(p0Num/p0Denom)          #change to log()
    return p0Vect,p1Vect,pAbusive

使用算法分类

def classifyNB(vec2Classify, p0Vec, p1Vec, pAb):
    # 相当于P(W0|ci)+P(W1|ci)+P(W2|ci)...+P(Wn|ci) =>
    # 因为P(w)P(ci)两者是一样的，可以忽略
    p1 = sum(vec2Classify * p1Vec) + log(pAb)    #element-wise mult
    p0 = sum(vec2Classify * p0Vec) + log(1.0 - pAb)
    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(array(trainMat),array(listClasses))
    testEntry = ['love', 'my', 'dalmation']
    thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
    print testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb)
    testEntry = ['stupid', 'garbage']
    thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
    print testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb)

文档词袋模型

我们将一个次的出现与否作为一个特征，这可以被描述为词集模型（set-of-words model）。如果一个词在文档中出现不止一次，
这可能意味着包含该词但是否出现在文档中所不能表达的某种信息，这种方法被称为词袋模型（bag-of-words model）。在词袋中，每个单词可以出现多次。

def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
    return returnVec

把setOfWords2Vec替换成bagOfWords2VecMN

总结

对于分类而言，使用概率有时要比使用硬规则更为有效。可以通过特征之间的条件独立性假设，降低对数据量的需求。当然我们知道这个假设过于简单，所以称为朴素贝叶斯的原因。尽管条件独立性假设并不正确，但是朴素贝叶斯是一种有效的分类器。

词袋模型在解决文档分类问题上比词集模型有所提高。

可以移除高频词和去除停用词表中的词来提高分类准确率。

去除高频词
def calcMostFreq(vocabList,fullText):
    import operator
    freqDict = {}
    for token in vocabList:
        freqDict[token]=fullText.count(token)
    sortedFreq = sorted(freqDict.iteritems(), key=operator.itemgetter(1), reverse=True) 
    return sortedFreq[:30]  

优点

• 在数据较少的情况下任然有效，可以处理多类别问题

缺点

• 对于输入数据的准备方式较为敏感