《机器学习实战》学习笔记五：朴素贝叶斯分类

1.贝叶斯决策理论
如图，在数据集中有两类数据，分布如下：

我们用p1（x，y）和p2（x，y）分别表示某一数据点在两类数据中的概率，那么对于一个新的数据点，可以用以下规则来判断它的类别：
若p1（x，y） > p2（x，y），则为类别1
若p1（x，y） < p2（x，y），则为类别2
这就是贝叶斯决策的思想，即选择具有最高概率的决策。

2.一些概率论基础
那么这个概率要如何计算呢？这里补充一些概率论的基础。
条件概率：
P(A|B)=P(A∩B)/P(B)
P(A∩B)=P(A|B)*P(B)=P(B|A)*P(A)
贝叶斯推断：
将条件概率变形可得：P(A|B)=P(B|A)*P(A)/P(B)
该公式被称为贝叶斯推断
朴素贝叶斯：
朴素贝叶斯是在条件概率的基础上做了独立性的假设，如以下公式，假设有n个特征：
P(A|X)=P(X|A)*P(A)=P(X1,X2,X3,…Xn|A)*P(A)
若每个特征都相互独立，则可以将公式拆分为：
P(A|X)=P(X|A)P(A)={P(X1|A)P(X2|A)*P(X3|A)…*P(Xn|A)}*P(A)
以上称为朴素贝叶斯推论

3.使用朴素贝叶斯进行分类

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

def createVocabList(dataSet):
    vocabSet = set([])        #创建一个无序不重复集合
    for document in dataSet:
        vocabSet = vocabSet|set(document)   #并集
    return list(vocabSet)

def setOfWords2Vec(vocabList,inputSet):
    returnVec = [0]*len(vocabList)   #创建一个元素全为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

分类器训练函数：
这一部分将应用贝叶斯公式通过词向量来计算概率，将公式改写为：
P(Ci|W)=P(W|Ci)P(Ci)/P(W)
根据公式，首先要计算P(Ci)，即侮辱性或者非侮辱性文档的在总文档中的概率，这个比较容易计算，然后计算P(W|Ci)，此时会用到朴素贝叶斯假设，假设W和C都相互独立，那么P(w|Ci)=P(W0|Ci)P(W1|Ci)P(W2|Ci)…P(Wn|Ci),这样计算起来就方便多了。
实现代码如下：

def trainNB0(trainMatrix,trainCategory): #输入词向量矩阵和标签向量
    numTrainDocs = len(trainMatrix)  #文档数
    numWords = len(trainMatrix[0])   #每个文档的单词数
    pAbusive = sum(trainCategory)/float(numTrainDocs) #侮辱性文档比例
    p0Num = ones(numWords);p1Num = ones(numWords)    #初始化变量，为了避免除以0和乘以0的影响，将zeros（）改为ones（）
    p0Denom = 2.0;p1Denom = 2.0                   #同上将0.0改为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])
    p1Vect = log(p1Num/p1Denom)                 #改为log（）
    p0Vect = log(p0Num/p0Denom)
    return p0Vect,p1Vect,pAbusive

函数输入两个参数，分别是文档词向量矩阵，和标签向量，首先计算侮辱性文档的概率，然后计算P（Wi|C0）和P（Wi|C1），需要初始化分子和分母的变量，然后遍历文档，一旦某有侮辱性单词或者非侮辱性词出现，便将该词对应的个数(p1Num或者p0Num)加1，同时该文档的总词数也要加1，最后对每个元素都除以该类别的总词数（利用NumPy库可实现一个数组除以浮点数），最后返回两个向量和一个概率。

构建分类器：

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

测试分类器：

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))

词袋模型：
以是否出现为特征的模型叫作词集模型，以出现次数为特征的模型叫作词袋模型，词袋模型在遇到单词时会将对应的词向量的值加1，代码如下：

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

以上这些工作，分类器就做好了，下一节将利用分类器操作一些实例。