机器学习实战之朴素贝叶斯

在学习了朴素贝叶斯理论之后,我们在这一部分将进行代码的实战，主要参考的材料也是《机器学习实战》这本书。

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

利用机器学习的知识对文档进行分类是一个很重要的应用。思路主要是将每个词出现或者不出现作为一个特征，这样特征数目就和词汇表中的数目一样多，在对其进行分析。

朴素贝叶斯的一般过程：

（1）收集数据：任何可收集到的方法。（这里用RSS源数据）
（2）准备数据：数据类型要是数值或者布尔型
（3）分析数据：大量特征时，绘制特征作用不大，直接用直方图效果更好
（4）训练算法：计算不同的独立特征的条件概率
（5）测试算法：计算训练出的模型在测试集上的错误率
（6）使用算法：可在任意的分类场景使用

接下来介绍一个用朴素贝叶斯分类器对垃圾邮件分类的代码：

from numpy import *

#这里loadDataSet创建了一些实验的样本
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) #方法是取原来集合和新集合的并集，获得新的vocabSet
    return list(vocabSet)

def setOfWords2Vec(vocabList,inputSet):
    
    '''
    这个函数输入的是词汇表和一个新文档，输出的是一个01向量，0代表没有在词汇表中出现，1代表出现了
    '''
    
    returnVec = [0] * len(vocabList) #创建一个和vocabList长度相同的0向量
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] = 1 #如果inputSet里的词在vocabList出现，则向量对应的index处变为1
        else:
            print('the word %s is not in my Vocabulary!' % word)
    return returnVec


def trainNB0(trainMatrix,trainCategory):
    
    '''
    利用朴素贝叶斯分类器训练我们的分类函数
    返回的是
    p0Vec:非侮辱性文档的出现的词的概率向量
    p1Vec:含侮辱性文字文档中的出现的词的概率向量
    pAbusive：侮辱性文档的概率
    '''
    
    numTrainDocs = len(trainMatrix) #训练集中的文档的数目
    numWords = len(trainMatrix[0]) #词的数目
    
    pAbusive = sum(trainCategory)/float(numTrainDocs) #含有侮辱性词的文档的概率 Abusive：侮辱性
    
    '''
    p0Num = zeros(numWords);p1Num = zeros(numWords) #初始化
    p0Denom = 0.0;p1Denom = 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] #这是一个类别为1的词汇出现次数的向量
            p1Denom += sum(trainMatrix[i]) #这是一个类别为1的总的词汇出现的个数
        else:
            p0Num += trainMatrix[i] #这是一个类别为0的词汇出现次数的向量
            p0Denom += sum(trainMatrix[i]) #这是一个类别为0的总的词汇出现的个数
    '''       
    p1Vec = p1Num/p1Denom #这是一个类别为1的每个词汇出现的概率的向量
    p0Vec = p0Num/p0Denom #这是一个类别为0的每个词汇出现的概率的向量
    '''
    #用取对数法来防止下溢出
    p1Vec = log(p1Num/p1Denom) #这是一个类别为1的每个词汇出现的概率的向量
    p0Vec = log(p0Num/p0Denom) #这是一个类别为0的每个词汇出现的概率的向量    
    
    return p0Vec,p1Vec,pAbusive


def classifyNB(vec2Calssify,p0Vec,p1Vec,pClass1):
    
    '''
    这是朴素贝叶斯的分类函数，返回的是最后分类的类别
    
    输入的参数
    vec2Calssify:要判别的向量
    p0Vec:非侮辱性词汇的出现概率的对数向量
    p1Vec:含侮辱性词汇的出现概率的对数向量
    pClass1:属于类别1的概率
    
    输出的参数
    1:含侮辱性词汇
    0:不含侮辱性词汇
    '''
    
    p1 = sum(vec2Calssify * p1Vec) + log(pClass1)    #这是该词向量属于第1类的可能性
    p0 = sum(vec2Calssify * p0Vec) + log(1-pClass1)  #这是该词向量属于第0类的可能性
    
    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(trainMat,listClasses)
    
    test1 = ['love','my','dalmation']
    doc1 = setOfWords2Vec(MyvocabList,test1)
    print(test1,'Classified as:',classifyNB(doc1,p0v,p1v,pab))
    
    
    test2 = ['stupid','garbage']
    doc2 = setOfWords2Vec(MyvocabList,test2)
    print(test2,'Classified as:',classifyNB(doc2,p0v,p1v,pab))
    
    
def bagOfWords2VecMN(vocabList,inputSet):
    
    '''
    这是一个文档词袋模型，和词集模型(set-of-words-model)类似，不同的是词袋模型会记录词出现的次数，词集模型只记录是否出现
    '''
    
    returnVec = [0] * len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
        else:
            print('%s 这个词不在我们的词表中' % word)
    
    return returnVec


def textParse(bigString):
    
    '''
    该函数用来进行语句分割
    分离出所有的词并且统一为小写字母
    '''
    
    import re
    listOfTokens = re.split(r'\W+',bigString)
    listOfTokens = [tok.lower() for tok in listOfTokens if len(tok) > 2]
    
    return listOfTokens

def spamTest():
    
    '''
    垃圾邮件分类测试函数
    '''
    
    docList = []; classList = []; fullText = [] #分别为文档列表，类别列表（垃圾邮件or not），全文词汇
    
    #将文档数据导入到上面到列表中
    for i in range(1,26):
        wordList = textParse(open('email/spam/%d.txt' % i,encoding='utf-8',errors = 'ignore').read())
        docList.append(wordList)
        classList.append(1)
        fullText.extend(wordList)
        wordList = textParse(open('email/ham/%d.txt' % i,encoding='utf-8',errors = 'ignore').read())
        docList.append(wordList)
        classList.append(0)
        fullText.extend(wordList)
    
    vocabList = createVocabList(docList)
    trainSet = [i for i in range(50)]
    testSet = []
    #随机构建训练集（从集合里删除十个不同邮件作为测试集）
    for i in range(10):
        randIndex = int(random.uniform(0,len(trainSet)))
        testSet.append(trainSet[randIndex])
        del(trainSet[randIndex])
    #创建训练集
    trainMat = [];trainClass = []
    for docIndex in trainSet:
        trainMat.append(setOfWords2Vec(vocabList,docList[docIndex]))
        trainClass.append(classList[docIndex])
    #用NB训练数据
    p0v,p1v,pSpam = trainNB0(trainMat,trainClass)
    
    error_count = 0
    
    #创建测试集并测试
    for docIndex in testSet:
        wordVector = setOfWords2Vec(vocabList,docList[docIndex])
        if classifyNB(wordVector,p0v,p1v,pSpam) != classList[docIndex]:
            error_count += 1
    print('the error rate is:%f' % (error_count/len(testSet)))

spamTest()

参考资料：
机器学习实战 Peter Harrington著 李锐 李鹏 曲亚东 王斌 译