朴素贝叶斯分类器

一、朴素贝叶斯分类的原理

      通过对某对象的先验概率，利用贝叶斯公式计算出其后验概率，即该对象属于某一类别的概率，选择有最大的后验概率类别         作为该对象的所属类别。

      转化成为概率表示：现在我们假设有一个数据集，它由两类数据组成，我们用表示(x,y)属于类别1的概率，用          表示数据点属于第二类的概率，那么，对于一个新的数据点，我们可以用下面的判断规则进行判断：若

    >，则类别为1，否则类别为2.我们在利用概率进行分类的时候，采用的概率计算公式为：

                                    

        公式的推导过程如下：

                                      

         由上面的两个式子可以推出：

                                     

        其中为后验概率，为联合概率

二、模型评价

      优点：在数据较少的情况下，可以处理多类别的问题

      缺点：对于输入数据的准备方式较为敏感

      适用数据类型：标称型数据

三、使用贝叶斯进行文档分类

      机器学习的一个重要的应用就是文档的自动分类。在文档分类的过程中，整个文档是实例，而电子邮件中的某些元素则构成         特征。虽然电子邮件是一种会不断增加的文本，但是我们同样也可以对新闻报道、用户留言、政府公文等其他任意类型的文         本进行分类。我们可以观察文本中出现的词，并把每个词的出现或者不出现作为一个特征，这样得到的特征数目就会跟词汇         表中的题目一样多。

      朴素贝叶斯的一般过程：（1）收集数据

                                         （2）准备数据：需要数值型或者布尔型数据

                                         （3）分析数据：由大量特征时，绘制特征作用不大，此时使用直方图效果更好

                                         （4）训练算法：计算不同的独立特征的条件概率

                                         （5）测试算法：计算错误率

                                         （6）使用算法：常见的就是文档分类

四、案例分析：

      ---言论过滤器

      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]
    return postingList,classVec

def createVocabList(dataSet):
    vocabSet=set([])                     #创建一个空的没有重复的列表
    for document in dataSet:             #对于dataSet进行遍历
        vocabSet=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:
            print('the word:%s is not in my Vocabulary!')%word
    return returnVec

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

              朴素贝叶斯分类器训练函数：

def trainNBO(trainMatrix,trainCategory):
    numTrainDocs=len(trainMatrix)                         #计算训练文档的数目
    numWords=len(trainMatrix[0])                          #计算每篇文档的此词条数
    pAbusive=sum(trainCategory)/float(numTrainDocs)       #文档属于侮辱类的概率
    p0Num=np.zeros(numWords);p1Num=np.zeros(numWords)     #构建numpy.zeros()数组
    p0Denom=0.0;p1Denom=0.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

        3、测试算法：根据实际情况修改分类器

             利用贝叶斯分类器对文档进行分类时，要计算多个概率的乘积以获得文档属于某个类别的概率。如果其中一个概率值为              0，那么最后的乘积也为0.为降低这种影响，可以将所有词出现的数初始化为1，并将分母初始化为2；另外一个问题是                下溢出，这是由于太多很小的数相乘造成的，一种解决办法是对于乘积取自然对数。

             朴素贝叶斯分类函数代码：

def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):
    p1=sum(vec2Classify*p1Vec)+np.log(pClass1)
    p0=sum(vec2Classify*p0Vec)+np.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=trainNBO(np.array(trainMat),np.array(listClasses))
    testEntry=['love','my','dalmation']
    thisDoc=np.array(setOfWords2Vec(myVocabList,testEntry))
    print (testEntry,'classified as:',classifyNB(thisDoc,p0V,p1V,pAb))
    testEntry=['stupid','garbage']
    thisDoc=np.array(setOfWords2Vec(myVocabList,testEntry))
    print (testEntry,'classified as:',classifyNB(thisDoc,p0V,p1V,pAb))

         ---垃圾邮件过滤

         1、准备数据：切分文本

def textParse(bigString):   
    import re                                #导入正则表达式的库
    listOfTokens=re.split(r'\W*',bigString)  #接受一个大字符串并将其解析为字符串列表，
                                             #该函数去掉少于两个字符的字符串，*代表无数次
    return[tok.lower() for tok in listOfTokens if len(tok)>2] #lower()将所有的字符串转化为小写

       上述函数是接受一个大写字符串并将其解析为字符串列表，该函数去掉少于两个字符的字符串，并将其所有的字符串转换为        小写。

          2、构建词条向量：

def setOfWords2Vec(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 

def createVocabList(dataSet):
    vocabSet=set([])
    for document in dataSet:
        vocabSet=vocabSet|set(document)
    return list(vocabSet)

        3、训练分类器

def trainNB0(trainMatrix,trainCategory):
    numTrainDocs=len(trainMatrix)
    numWords=len(trainMatrix[0])
    pAbusive=sum(trainCategory)/float(numTrainDocs)
    p0Num=np.zeros(numWords);p1Num=np.zeros(numWords)
    p0Denom=2.0;p1Denom=2.0  #分母初始化为2，拉普拉斯平滑
    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

        4、测试算法

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

def spamTest():                             #对于贝叶斯垃圾邮件分类器进行自动化处理,导入文件spam和ham下的文本文件，并将他们解析为词列表
    docList=[];classList=[];fullText=[]
    for i in range(1,26):
        wordList=textParse(open('email/email/spam/%d.txt' % i).read())  #textParse()接受一个大写字符串并将其解析为字符串列表
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1)                                             #设置垃圾邮件类别为1
        wordList=textParse(open('email/email/ham/%d.txt' % i).read())   #将ham文件里面的邮件内容读取出来
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)                                             #设置邮件类别为0
    vocabList=createVocabList(docList)                                  #生成词表库
    trainingSet=list(range(50));testSet=[]                              #trainingSet（）是一个完整的列表，值从0到49
    for i in range(10):                    #随机选择10组作为测试集，选择的数据文档被添加到测试集，同时也将其从训练集中剔除
        randIndex=int(np.random.uniform(0,len(trainingSet)))
        testSet.append(trainingSet[randIndex])
        del(trainingSet[randIndex])
    trainMat=[];trainClasses=[]
    for docIndex in trainingSet:                                       #生成训练矩阵及其标签
        trainMat.append(setOfWords2Vec(vocabList,docList[docIndex]))
        trainClasses.append(classList[docIndex])
    p0V,p1V,pSpam=trainNB0(np.array(trainMat),np.array(trainClasses))
    errorCount=0
    for docIndex in testSet:
        wordVector=setOfWords2Vec(vocabList,docList[docIndex])
        if classifyNB(np.array(wordVector),p0V,p1V,pSpam)!=classList[docIndex]:
            errorCount+=1
    print('the error rate is: ',float(errorCount)/len(testSet))

         函数spamTest()对于贝叶斯垃圾邮件分类器进行自动化处理，导入文件夹spam与ham下的文本文件，并将它们解析为词           列表。接下来构建一个测试集与训练集，两个集合中的邮件都是随机挑选出来的。分类器所需要的概率计算只利用训练集中         的文档来完成。